Merge branch 'httpc' into online
This commit is contained in:
PabloMK7
commit
f313dabb93
2
externals/httplib/README.md
vendored
2
externals/httplib/README.md
vendored
@ -1,4 +1,4 @@
|
||||
From https://github.com/yhirose/cpp-httplib/commit/8e10d4e8e7febafce0632810262e81e853b2065f
|
||||
From https://github.com/yhirose/cpp-httplib/commit/0a629d739127dcc5d828474a5aedae1f234687d3
|
||||
|
||||
MIT License
|
||||
|
||||
|
||||
1856
externals/httplib/httplib.h
vendored
1856
externals/httplib/httplib.h
vendored
File diff suppressed because it is too large
Load Diff
@ -3,7 +3,9 @@
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <atomic>
|
||||
#include <tuple>
|
||||
#include <unordered_map>
|
||||
#include <boost/algorithm/string/replace.hpp>
|
||||
#include <cryptopp/aes.h>
|
||||
#include <cryptopp/modes.h>
|
||||
#include "common/archives.h"
|
||||
@ -28,6 +30,8 @@ enum {
|
||||
InvalidRequestState = 22,
|
||||
TooManyContexts = 26,
|
||||
InvalidRequestMethod = 32,
|
||||
HeaderNotFound = 40,
|
||||
BufferTooSmall = 43,
|
||||
ContextNotFound = 100,
|
||||
|
||||
/// This error is returned in multiple situations: when trying to initialize an
|
||||
@ -48,6 +52,10 @@ const ResultCode ERROR_NOT_IMPLEMENTED = // 0xD960A3F4
|
||||
const ResultCode ERROR_TOO_MANY_CLIENT_CERTS = // 0xD8A0A0CB
|
||||
ResultCode(ErrCodes::TooManyClientCerts, ErrorModule::HTTP, ErrorSummary::InvalidState,
|
||||
ErrorLevel::Permanent);
|
||||
const ResultCode ERROR_HEADER_NOT_FOUND = ResultCode(
|
||||
ErrCodes::HeaderNotFound, ErrorModule::HTTP, ErrorSummary::InvalidState, ErrorLevel::Permanent);
|
||||
const ResultCode ERROR_BUFFER_SMALL = ResultCode(ErrCodes::BufferTooSmall, ErrorModule::HTTP,
|
||||
ErrorSummary::WouldBlock, ErrorLevel::Permanent);
|
||||
const ResultCode ERROR_WRONG_CERT_ID = // 0xD8E0B839
|
||||
ResultCode(57, ErrorModule::SSL, ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
|
||||
const ResultCode ERROR_WRONG_CERT_HANDLE = // 0xD8A0A0C9
|
||||
@ -55,47 +63,72 @@ const ResultCode ERROR_WRONG_CERT_HANDLE = // 0xD8A0A0C9
|
||||
const ResultCode ERROR_CERT_ALREADY_SET = // 0xD8A0A03D
|
||||
ResultCode(61, ErrorModule::HTTP, ErrorSummary::InvalidState, ErrorLevel::Permanent);
|
||||
|
||||
static std::pair<std::string, std::string> SplitUrl(const std::string& url) {
|
||||
static ssize_t write_headers(httplib::Stream& strm,
|
||||
const std::vector<Context::RequestHeader>& headers) {
|
||||
ssize_t write_len = 0;
|
||||
for (const auto& x : headers) {
|
||||
auto len = strm.write_format("%s: %s\r\n", x.name.c_str(), x.value.c_str());
|
||||
if (len < 0) {
|
||||
return len;
|
||||
}
|
||||
write_len += len;
|
||||
}
|
||||
auto len = strm.write("\r\n");
|
||||
if (len < 0) {
|
||||
return len;
|
||||
}
|
||||
write_len += len;
|
||||
return write_len;
|
||||
}
|
||||
|
||||
static std::tuple<std::string, int, std::string, bool> SplitUrl(const std::string& url) {
|
||||
const std::string prefix = "://";
|
||||
const auto scheme_end = url.find(prefix);
|
||||
const auto prefix_end = scheme_end == std::string::npos ? 0 : scheme_end + prefix.length();
|
||||
|
||||
bool is_https = scheme_end != std::string::npos && url.starts_with("https");
|
||||
|
||||
const auto path_index = url.find("/", prefix_end);
|
||||
std::string host;
|
||||
int port = -1;
|
||||
std::string path;
|
||||
if (path_index == std::string::npos) {
|
||||
// If no path is specified after the host, set it to "/"
|
||||
host = url;
|
||||
host = url.substr(prefix_end);
|
||||
const auto port_start = host.find(":");
|
||||
if (port_start != std::string::npos) {
|
||||
std::string port_str = host.substr(port_start + 1);
|
||||
host = host.substr(0, port_start);
|
||||
char* pEnd = NULL;
|
||||
port = std::strtol(port_str.c_str(), &pEnd, 10);
|
||||
if (*pEnd) {
|
||||
port = -1;
|
||||
}
|
||||
}
|
||||
path = "/";
|
||||
} else {
|
||||
host = url.substr(0, path_index);
|
||||
host = url.substr(prefix_end, path_index - prefix_end);
|
||||
const auto port_start = host.find(":");
|
||||
if (port_start != std::string::npos) {
|
||||
std::string port_str = host.substr(port_start + 1);
|
||||
host = host.substr(0, port_start);
|
||||
char* pEnd = NULL;
|
||||
port = std::strtol(port_str.c_str(), &pEnd, 10);
|
||||
if (*pEnd) {
|
||||
port = -1;
|
||||
}
|
||||
}
|
||||
path = url.substr(path_index);
|
||||
}
|
||||
return std::make_pair(host, path);
|
||||
if (port == -1) {
|
||||
port = is_https ? 443 : 80;
|
||||
}
|
||||
return std::make_tuple(host, port, path, is_https);
|
||||
}
|
||||
|
||||
void Context::MakeRequest() {
|
||||
ASSERT(state == RequestState::NotStarted);
|
||||
|
||||
const auto& [host, path] = SplitUrl(url);
|
||||
const auto client = std::make_unique<httplib::Client>(host);
|
||||
SSL_CTX* ctx = client->ssl_context();
|
||||
if (ctx) {
|
||||
if (auto client_cert = ssl_config.client_cert_ctx.lock()) {
|
||||
SSL_CTX_use_certificate_ASN1(ctx, static_cast<int>(client_cert->certificate.size()),
|
||||
client_cert->certificate.data());
|
||||
SSL_CTX_use_PrivateKey_ASN1(EVP_PKEY_RSA, ctx, client_cert->private_key.data(),
|
||||
static_cast<long>(client_cert->private_key.size()));
|
||||
}
|
||||
|
||||
// TODO(B3N30): Check for SSLOptions-Bits and set the verify method accordingly
|
||||
// https://www.3dbrew.org/wiki/SSL_Services#SSLOpt
|
||||
// Hack: Since for now RootCerts are not implemented we set the VerifyMode to None.
|
||||
SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
|
||||
}
|
||||
|
||||
state = RequestState::InProgress;
|
||||
|
||||
static const std::unordered_map<RequestMethod, std::string> request_method_strings{
|
||||
{RequestMethod::Get, "GET"}, {RequestMethod::Post, "POST"},
|
||||
{RequestMethod::Head, "HEAD"}, {RequestMethod::Put, "PUT"},
|
||||
@ -103,11 +136,14 @@ void Context::MakeRequest() {
|
||||
{RequestMethod::PutEmpty, "PUT"},
|
||||
};
|
||||
|
||||
const auto& [host, port, path, is_https] = SplitUrl(url.c_str());
|
||||
|
||||
httplib::Request request;
|
||||
httplib::Error error;
|
||||
httplib::Error error{-1};
|
||||
std::vector<Context::RequestHeader> pending_headers;
|
||||
request.method = request_method_strings.at(method);
|
||||
request.path = path;
|
||||
// TODO(B3N30): Add post data body
|
||||
|
||||
request.progress = [this](u64 current, u64 total) -> bool {
|
||||
// TODO(B3N30): Is there a state that shows response header are available
|
||||
current_download_size_bytes = current;
|
||||
@ -115,17 +151,135 @@ void Context::MakeRequest() {
|
||||
return true;
|
||||
};
|
||||
|
||||
for (const auto& header : headers) {
|
||||
request.headers.emplace(header.name, header.value);
|
||||
// Watch out for header ordering!
|
||||
auto header_writter = [&pending_headers](httplib::Stream& strm,
|
||||
httplib::Headers& httplib_headers) {
|
||||
std::vector<Context::RequestHeader> final_headers;
|
||||
std::vector<Context::RequestHeader>::iterator it_p;
|
||||
httplib::Headers::iterator it_h;
|
||||
|
||||
auto find_pending_header = [&pending_headers](const std::string& str) {
|
||||
return std::find_if(pending_headers.begin(), pending_headers.end(),
|
||||
[&str](Context::RequestHeader& rh) { return rh.name == str; });
|
||||
};
|
||||
|
||||
// First: Host
|
||||
it_p = find_pending_header("Host");
|
||||
if (it_p != pending_headers.end()) {
|
||||
final_headers.push_back(Context::RequestHeader(it_p->name, it_p->value));
|
||||
pending_headers.erase(it_p);
|
||||
} else {
|
||||
it_h = httplib_headers.find("Host");
|
||||
if (it_h != httplib_headers.end()) {
|
||||
final_headers.push_back(Context::RequestHeader(it_h->first, it_h->second));
|
||||
}
|
||||
}
|
||||
|
||||
// Second: Content-Type (optional, ignore httplib)
|
||||
it_p = find_pending_header("Content-Type");
|
||||
if (it_p != pending_headers.end()) {
|
||||
final_headers.push_back(Context::RequestHeader(it_p->name, it_p->value));
|
||||
pending_headers.erase(it_p);
|
||||
}
|
||||
|
||||
// Third: Content-Length
|
||||
it_p = find_pending_header("Content-Length");
|
||||
if (it_p != pending_headers.end()) {
|
||||
final_headers.push_back(Context::RequestHeader(it_p->name, it_p->value));
|
||||
pending_headers.erase(it_p);
|
||||
} else {
|
||||
it_h = httplib_headers.find("Content-Length");
|
||||
if (it_h != httplib_headers.end()) {
|
||||
final_headers.push_back(Context::RequestHeader(it_h->first, it_h->second));
|
||||
}
|
||||
}
|
||||
|
||||
// Finally, user defined headers
|
||||
for (const auto& header : pending_headers) {
|
||||
final_headers.push_back(header);
|
||||
}
|
||||
|
||||
return write_headers(strm, final_headers);
|
||||
};
|
||||
|
||||
if (!post_data.empty()) {
|
||||
pending_headers.push_back(
|
||||
Context::RequestHeader("Content-Type", "application/x-www-form-urlencoded"));
|
||||
request.body = httplib::detail::params_to_query_str(post_data);
|
||||
boost::replace_all(request.body, "*", "%2A");
|
||||
}
|
||||
|
||||
if (!client->send(request, response, error)) {
|
||||
LOG_ERROR(Service_HTTP, "Request failed: {}: {}", error, httplib::to_string(error));
|
||||
state = RequestState::TimedOut;
|
||||
for (const auto& header : headers) {
|
||||
pending_headers.push_back(header);
|
||||
}
|
||||
|
||||
if (!post_data_raw.empty()) {
|
||||
request.body = post_data_raw;
|
||||
}
|
||||
|
||||
state = RequestState::InProgress;
|
||||
|
||||
// Sadly, we have to duplicate code, the class hierarchy in httplib is not very useful...
|
||||
if (is_https) {
|
||||
X509* cert = nullptr;
|
||||
EVP_PKEY* key = nullptr;
|
||||
{
|
||||
std::unique_ptr<httplib::SSLClient> client;
|
||||
if (uses_default_client_cert) {
|
||||
const unsigned char* tmpCertPtr = clcert_data->certificate.data();
|
||||
const unsigned char* tmpKeyPtr = clcert_data->private_key.data();
|
||||
cert = d2i_X509(nullptr, &tmpCertPtr, (long)clcert_data->certificate.size());
|
||||
key = d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &tmpKeyPtr,
|
||||
(long)clcert_data->private_key.size());
|
||||
client = std::make_unique<httplib::SSLClient>(host, port, cert, key);
|
||||
} else {
|
||||
if (auto client_cert = ssl_config.client_cert_ctx.lock()) {
|
||||
const unsigned char* tmpCertPtr = client_cert->certificate.data();
|
||||
const unsigned char* tmpKeyPtr = client_cert->private_key.data();
|
||||
cert = d2i_X509(nullptr, &tmpCertPtr, (long)client_cert->certificate.size());
|
||||
key = d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &tmpKeyPtr,
|
||||
(long)client_cert->private_key.size());
|
||||
client = std::make_unique<httplib::SSLClient>(host, port, cert, key);
|
||||
} else {
|
||||
client = std::make_unique<httplib::SSLClient>(host, port);
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(B3N30): Check for SSLOptions-Bits and set the verify method accordingly
|
||||
// https://www.3dbrew.org/wiki/SSL_Services#SSLOpt
|
||||
// Hack: Since for now RootCerts are not implemented we set the VerifyMode to None.
|
||||
client->enable_server_certificate_verification(false);
|
||||
|
||||
client->set_header_writer(header_writter);
|
||||
|
||||
if (!client->send(request, response, error)) {
|
||||
LOG_ERROR(Service_HTTP, "Request failed: {}: {}", error, httplib::to_string(error));
|
||||
state = RequestState::TimedOut;
|
||||
} else {
|
||||
LOG_DEBUG(Service_HTTP, "Request successful");
|
||||
// TODO(B3N30): Verify this state on HW
|
||||
state = RequestState::ReadyToDownloadContent;
|
||||
}
|
||||
}
|
||||
if (cert) {
|
||||
X509_free(cert);
|
||||
}
|
||||
if (key) {
|
||||
EVP_PKEY_free(key);
|
||||
}
|
||||
} else {
|
||||
LOG_DEBUG(Service_HTTP, "Request successful");
|
||||
// TODO(B3N30): Verify this state on HW
|
||||
state = RequestState::ReadyToDownloadContent;
|
||||
std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(host, port);
|
||||
|
||||
client->set_header_writer(header_writter);
|
||||
|
||||
if (!client->send(request, response, error)) {
|
||||
LOG_ERROR(Service_HTTP, "Request failed: {}: {}", error, httplib::to_string(error));
|
||||
state = RequestState::TimedOut;
|
||||
} else {
|
||||
LOG_DEBUG(Service_HTTP, "Request successful");
|
||||
// TODO(B3N30): Verify this state on HW
|
||||
state = RequestState::ReadyToDownloadContent;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -138,7 +292,7 @@ void HTTP_C::Initialize(Kernel::HLERequestContext& ctx) {
|
||||
shared_memory->SetName("HTTP_C:shared_memory");
|
||||
}
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, shared memory size: {} pid: {}", shmem_size, pid);
|
||||
LOG_DEBUG(Service_HTTP, "shared memory size: {} pid: {}", shmem_size, pid);
|
||||
|
||||
auto* session_data = GetSessionData(ctx.Session());
|
||||
ASSERT(session_data);
|
||||
@ -198,7 +352,7 @@ void HTTP_C::BeginRequest(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, context_id={}", context_handle);
|
||||
LOG_DEBUG(Service_HTTP, "context_id={}", context_handle);
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, context_handle)) {
|
||||
return;
|
||||
@ -207,6 +361,13 @@ void HTTP_C::BeginRequest(Kernel::HLERequestContext& ctx) {
|
||||
auto itr = contexts.find(context_handle);
|
||||
ASSERT(itr != contexts.end());
|
||||
|
||||
// This should never happen in real hardware, but can happen on citra.
|
||||
if (itr->second.uses_default_client_cert && !itr->second.clcert_data->init) {
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(ERROR_STATE_ERROR);
|
||||
return;
|
||||
}
|
||||
|
||||
// On a 3DS BeginRequest and BeginRequestAsync will push the Request to a worker queue.
|
||||
// You can only enqueue 8 requests at the same time.
|
||||
// trying to enqueue any more will either fail (BeginRequestAsync), or block (BeginRequest)
|
||||
@ -216,6 +377,7 @@ void HTTP_C::BeginRequest(Kernel::HLERequestContext& ctx) {
|
||||
|
||||
itr->second.request_future =
|
||||
std::async(std::launch::async, &Context::MakeRequest, std::ref(itr->second));
|
||||
itr->second.current_copied_data = 0;
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
@ -225,7 +387,7 @@ void HTTP_C::BeginRequestAsync(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, context_id={}", context_handle);
|
||||
LOG_WARNING(Service_HTTP, "context_id={}", context_handle);
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, context_handle)) {
|
||||
return;
|
||||
@ -234,6 +396,13 @@ void HTTP_C::BeginRequestAsync(Kernel::HLERequestContext& ctx) {
|
||||
auto itr = contexts.find(context_handle);
|
||||
ASSERT(itr != contexts.end());
|
||||
|
||||
// This should never happen in real hardware, but can happen on citra.
|
||||
if (itr->second.uses_default_client_cert && !itr->second.clcert_data->init) {
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(ERROR_STATE_ERROR);
|
||||
return;
|
||||
}
|
||||
|
||||
// On a 3DS BeginRequest and BeginRequestAsync will push the Request to a worker queue.
|
||||
// You can only enqueue 8 requests at the same time.
|
||||
// trying to enqueue any more will either fail (BeginRequestAsync), or block (BeginRequest)
|
||||
@ -243,6 +412,7 @@ void HTTP_C::BeginRequestAsync(Kernel::HLERequestContext& ctx) {
|
||||
|
||||
itr->second.request_future =
|
||||
std::async(std::launch::async, &Context::MakeRequest, std::ref(itr->second));
|
||||
itr->second.current_copied_data = 0;
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
@ -258,30 +428,98 @@ void HTTP_C::ReceiveDataTimeout(Kernel::HLERequestContext& ctx) {
|
||||
|
||||
void HTTP_C::ReceiveDataImpl(Kernel::HLERequestContext& ctx, bool timeout) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
[[maybe_unused]] const u32 buffer_size = rp.Pop<u32>();
|
||||
u64 timeout_nanos = 0;
|
||||
if (timeout) {
|
||||
timeout_nanos = rp.Pop<u64>();
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, timeout={}", timeout_nanos);
|
||||
} else {
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called");
|
||||
}
|
||||
[[maybe_unused]] Kernel::MappedBuffer& buffer = rp.PopMappedBuffer();
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, context_handle)) {
|
||||
struct AsyncData {
|
||||
// Input
|
||||
HTTP_C* own;
|
||||
u64 timeout_nanos = 0;
|
||||
bool timeout;
|
||||
Context::Handle context_handle;
|
||||
u32 buffer_size;
|
||||
Kernel::MappedBuffer* buffer;
|
||||
bool is_complete;
|
||||
// Output
|
||||
ResultCode async_res = RESULT_SUCCESS;
|
||||
};
|
||||
std::shared_ptr<AsyncData> async_data = std::make_shared<AsyncData>();
|
||||
async_data->own = this;
|
||||
async_data->timeout = timeout;
|
||||
|
||||
async_data->context_handle = rp.Pop<u32>();
|
||||
async_data->buffer_size = rp.Pop<u32>();
|
||||
|
||||
if (timeout) {
|
||||
async_data->timeout_nanos = rp.Pop<u64>();
|
||||
LOG_DEBUG(Service_HTTP, "timeout={}", async_data->timeout_nanos);
|
||||
} else {
|
||||
LOG_DEBUG(Service_HTTP, "");
|
||||
}
|
||||
async_data->buffer = &rp.PopMappedBuffer();
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, async_data->context_handle)) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto itr = contexts.find(context_handle);
|
||||
ASSERT(itr != contexts.end());
|
||||
ctx.RunAsync(
|
||||
[async_data](Kernel::HLERequestContext& ctx) {
|
||||
auto itr = async_data->own->contexts.find(async_data->context_handle);
|
||||
ASSERT(itr != async_data->own->contexts.end());
|
||||
|
||||
if (timeout) {
|
||||
itr->second.request_future.wait_for(std::chrono::nanoseconds(timeout_nanos));
|
||||
// TODO (flTobi): Return error on timeout
|
||||
} else {
|
||||
itr->second.request_future.wait();
|
||||
}
|
||||
Context& http_context = itr->second;
|
||||
|
||||
if (async_data->timeout) {
|
||||
auto wait_res = http_context.request_future.wait_for(
|
||||
std::chrono::nanoseconds(async_data->timeout_nanos));
|
||||
if (wait_res == std::future_status::timeout) {
|
||||
async_data->async_res =
|
||||
ResultCode(105, ErrorModule::HTTP, ErrorSummary::NothingHappened,
|
||||
ErrorLevel::Permanent);
|
||||
}
|
||||
} else {
|
||||
http_context.request_future.wait();
|
||||
}
|
||||
// Simulate small delay from HTTP receive.
|
||||
return 1'000'000;
|
||||
},
|
||||
[async_data](Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestBuilder rb(ctx, static_cast<u16>(ctx.CommandHeader().command_id.Value()), 1,
|
||||
0);
|
||||
if (async_data->async_res != RESULT_SUCCESS) {
|
||||
rb.Push(async_data->async_res);
|
||||
return;
|
||||
}
|
||||
auto itr = async_data->own->contexts.find(async_data->context_handle);
|
||||
ASSERT(itr != async_data->own->contexts.end());
|
||||
|
||||
Context& http_context = itr->second;
|
||||
|
||||
size_t remaining_data =
|
||||
http_context.response.body.size() - http_context.current_copied_data;
|
||||
|
||||
if (async_data->buffer_size >= remaining_data) {
|
||||
async_data->buffer->Write(http_context.response.body.data() +
|
||||
http_context.current_copied_data,
|
||||
0, remaining_data);
|
||||
http_context.current_copied_data += remaining_data;
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
} else {
|
||||
async_data->buffer->Write(http_context.response.body.data() +
|
||||
http_context.current_copied_data,
|
||||
0, async_data->buffer_size);
|
||||
http_context.current_copied_data += async_data->buffer_size;
|
||||
rb.Push(ERROR_BUFFER_SMALL);
|
||||
}
|
||||
LOG_DEBUG(Service_HTTP, "Receive: buffer_size= {}, total_copied={}, total_body={}",
|
||||
async_data->buffer_size, http_context.current_copied_data,
|
||||
http_context.response.body.size());
|
||||
});
|
||||
}
|
||||
|
||||
void HTTP_C::SetProxyDefault(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, handle={}", context_handle);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
@ -359,7 +597,7 @@ void HTTP_C::CloseContext(Kernel::HLERequestContext& ctx) {
|
||||
|
||||
u32 context_handle = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, handle={}", context_handle);
|
||||
LOG_DEBUG(Service_HTTP, "handle={}", context_handle);
|
||||
|
||||
auto* session_data = EnsureSessionInitialized(ctx, rp);
|
||||
if (!session_data) {
|
||||
@ -389,6 +627,24 @@ void HTTP_C::CloseContext(Kernel::HLERequestContext& ctx) {
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void HTTP_C::CancelConnection(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const u32 context_handle = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, handle={}", context_handle);
|
||||
|
||||
const auto* session_data = EnsureSessionInitialized(ctx, rp);
|
||||
if (!session_data) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto itr = contexts.find(context_handle);
|
||||
ASSERT(itr != contexts.end());
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void HTTP_C::AddRequestHeader(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const u32 context_handle = rp.Pop<u32>();
|
||||
@ -424,11 +680,6 @@ void HTTP_C::AddRequestHeader(Kernel::HLERequestContext& ctx) {
|
||||
return;
|
||||
}
|
||||
|
||||
ASSERT(std::find_if(itr->second.headers.begin(), itr->second.headers.end(),
|
||||
[&name](const Context::RequestHeader& m) -> bool {
|
||||
return m.name == name;
|
||||
}) == itr->second.headers.end());
|
||||
|
||||
itr->second.headers.emplace_back(name, value);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
||||
@ -471,17 +722,119 @@ void HTTP_C::AddPostDataAscii(Kernel::HLERequestContext& ctx) {
|
||||
return;
|
||||
}
|
||||
|
||||
ASSERT(std::find_if(itr->second.post_data.begin(), itr->second.post_data.end(),
|
||||
[&name](const Context::PostData& m) -> bool { return m.name == name; }) ==
|
||||
itr->second.post_data.end());
|
||||
|
||||
itr->second.post_data.emplace_back(name, value);
|
||||
itr->second.post_data.emplace(name, value);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushMappedBuffer(value_buffer);
|
||||
}
|
||||
|
||||
void HTTP_C::AddPostDataRaw(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const u32 context_handle = rp.Pop<u32>();
|
||||
const u32 post_data_len = rp.Pop<u32>();
|
||||
auto buffer = rp.PopMappedBuffer();
|
||||
|
||||
LOG_DEBUG(Service_HTTP, "context_handle={}, post_data_len={}", context_handle, post_data_len);
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, context_handle)) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto itr = contexts.find(context_handle);
|
||||
ASSERT(itr != contexts.end());
|
||||
|
||||
if (itr->second.state != RequestState::NotStarted) {
|
||||
LOG_ERROR(Service_HTTP,
|
||||
"Tried to add post data on a context that has already been started.");
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
||||
rb.Push(ResultCode(ErrCodes::InvalidRequestState, ErrorModule::HTTP,
|
||||
ErrorSummary::InvalidState, ErrorLevel::Permanent));
|
||||
rb.PushMappedBuffer(buffer);
|
||||
return;
|
||||
}
|
||||
|
||||
itr->second.post_data_raw.resize(buffer.GetSize());
|
||||
buffer.Read(itr->second.post_data_raw.data(), 0, buffer.GetSize());
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushMappedBuffer(buffer);
|
||||
}
|
||||
|
||||
void HTTP_C::GetResponseHeader(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
|
||||
struct AsyncData {
|
||||
HTTP_C* own;
|
||||
u32 context_handle;
|
||||
u32 name_len;
|
||||
u32 value_max_len;
|
||||
const std::vector<u8>* header_name;
|
||||
Kernel::MappedBuffer* value_buffer;
|
||||
};
|
||||
std::shared_ptr<AsyncData> async_data = std::make_shared<AsyncData>();
|
||||
|
||||
async_data->own = this;
|
||||
async_data->context_handle = rp.Pop<u32>();
|
||||
async_data->name_len = rp.Pop<u32>();
|
||||
async_data->value_max_len = rp.Pop<u32>();
|
||||
async_data->header_name = &rp.PopStaticBuffer();
|
||||
async_data->value_buffer = &rp.PopMappedBuffer();
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, async_data->context_handle)) {
|
||||
return;
|
||||
}
|
||||
|
||||
ctx.RunAsync(
|
||||
[async_data](Kernel::HLERequestContext& ctx) {
|
||||
auto itr = async_data->own->contexts.find(async_data->context_handle);
|
||||
ASSERT(itr != async_data->own->contexts.end());
|
||||
|
||||
itr->second.request_future.wait();
|
||||
return 0;
|
||||
},
|
||||
[async_data](Kernel::HLERequestContext& ctx) {
|
||||
std::string header_name_str(
|
||||
reinterpret_cast<const char*>(async_data->header_name->data()),
|
||||
async_data->name_len);
|
||||
while (header_name_str.size() && header_name_str.back() == '\0') {
|
||||
header_name_str.pop_back();
|
||||
}
|
||||
|
||||
auto itr = async_data->own->contexts.find(async_data->context_handle);
|
||||
ASSERT(itr != async_data->own->contexts.end());
|
||||
|
||||
auto& headers = itr->second.response.headers;
|
||||
u32 copied_size = 0;
|
||||
|
||||
LOG_DEBUG(Service_HTTP, "header={}, max_len={}", header_name_str,
|
||||
async_data->value_buffer->GetSize());
|
||||
|
||||
auto header = headers.find(header_name_str);
|
||||
if (header != headers.end()) {
|
||||
std::string header_value = header->second;
|
||||
copied_size = (u32)header_value.size();
|
||||
if (header_value.size() + 1 > async_data->value_buffer->GetSize()) {
|
||||
header_value.resize(async_data->value_buffer->GetSize() - 1);
|
||||
}
|
||||
header_value.push_back('\0');
|
||||
async_data->value_buffer->Write(header_value.data(), 0, header_value.size());
|
||||
} else {
|
||||
LOG_DEBUG(Service_HTTP, "header={} not found", header_name_str);
|
||||
IPC::RequestBuilder rb(ctx, 0x001E, 1, 2);
|
||||
rb.Push(ERROR_HEADER_NOT_FOUND);
|
||||
rb.PushMappedBuffer(*async_data->value_buffer);
|
||||
return;
|
||||
}
|
||||
|
||||
IPC::RequestBuilder rb(ctx, 0x001E, 2, 2);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.Push(copied_size);
|
||||
rb.PushMappedBuffer(*async_data->value_buffer);
|
||||
});
|
||||
}
|
||||
|
||||
void HTTP_C::GetResponseStatusCode(Kernel::HLERequestContext& ctx) {
|
||||
GetResponseStatusCodeImpl(ctx, false);
|
||||
}
|
||||
@ -492,15 +845,105 @@ void HTTP_C::GetResponseStatusCodeTimeout(Kernel::HLERequestContext& ctx) {
|
||||
|
||||
void HTTP_C::GetResponseStatusCodeImpl(Kernel::HLERequestContext& ctx, bool timeout) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
u64 timeout_nanos = 0;
|
||||
|
||||
struct AsyncData {
|
||||
// Input
|
||||
HTTP_C* own;
|
||||
Context::Handle context_handle;
|
||||
bool timeout;
|
||||
u64 timeout_nanos = 0;
|
||||
// Output
|
||||
ResultCode async_res = RESULT_SUCCESS;
|
||||
};
|
||||
std::shared_ptr<AsyncData> async_data = std::make_shared<AsyncData>();
|
||||
|
||||
async_data->own = this;
|
||||
async_data->context_handle = rp.Pop<u32>();
|
||||
async_data->timeout = timeout;
|
||||
|
||||
if (timeout) {
|
||||
timeout_nanos = rp.Pop<u64>();
|
||||
LOG_INFO(Service_HTTP, "called, timeout={}", timeout_nanos);
|
||||
async_data->timeout_nanos = rp.Pop<u64>();
|
||||
LOG_INFO(Service_HTTP, "called, timeout={}", async_data->timeout_nanos);
|
||||
} else {
|
||||
LOG_INFO(Service_HTTP, "called");
|
||||
}
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, async_data->context_handle)) {
|
||||
return;
|
||||
}
|
||||
|
||||
ctx.RunAsync(
|
||||
[async_data](Kernel::HLERequestContext& ctx) {
|
||||
auto itr = async_data->own->contexts.find(async_data->context_handle);
|
||||
ASSERT(itr != async_data->own->contexts.end());
|
||||
|
||||
if (async_data->timeout) {
|
||||
auto wait_res = itr->second.request_future.wait_for(
|
||||
std::chrono::nanoseconds(async_data->timeout_nanos));
|
||||
if (wait_res == std::future_status::timeout) {
|
||||
LOG_DEBUG(Service_HTTP, "Status code: {}", "timeout");
|
||||
async_data->async_res =
|
||||
ResultCode(105, ErrorModule::HTTP, ErrorSummary::NothingHappened,
|
||||
ErrorLevel::Permanent);
|
||||
}
|
||||
} else {
|
||||
itr->second.request_future.wait();
|
||||
}
|
||||
return 0;
|
||||
},
|
||||
[async_data](Kernel::HLERequestContext& ctx) {
|
||||
if (async_data->async_res != RESULT_SUCCESS) {
|
||||
IPC::RequestBuilder rb(
|
||||
ctx, static_cast<u16>(ctx.CommandHeader().command_id.Value()), 1, 0);
|
||||
rb.Push(async_data->async_res);
|
||||
return;
|
||||
}
|
||||
|
||||
auto itr = async_data->own->contexts.find(async_data->context_handle);
|
||||
ASSERT(itr != async_data->own->contexts.end());
|
||||
|
||||
const u32 response_code = itr->second.response.status;
|
||||
LOG_DEBUG(Service_HTTP, "Status code: {}, response_code={}", "good", response_code);
|
||||
|
||||
IPC::RequestBuilder rb(ctx, static_cast<u16>(ctx.CommandHeader().command_id.Value()), 2,
|
||||
0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.Push(response_code);
|
||||
});
|
||||
}
|
||||
|
||||
void HTTP_C::AddTrustedRootCA(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
[[maybe_unused]] const u32 root_ca_len = rp.Pop<u32>();
|
||||
auto root_ca_data = rp.PopMappedBuffer();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, handle={}", context_handle);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushMappedBuffer(root_ca_data);
|
||||
}
|
||||
|
||||
void HTTP_C::AddDefaultCert(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
const u32 certificate_id = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, handle={}, certificate_id={}", context_handle,
|
||||
certificate_id);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void HTTP_C::SetDefaultClientCert(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const Context::Handle context_handle = rp.Pop<u32>();
|
||||
const u32 client_cert_id = rp.Pop<u32>();
|
||||
|
||||
LOG_DEBUG(Service_HTTP, "client_cert_id={}", client_cert_id);
|
||||
|
||||
if (!PerformStateChecks(ctx, rp, context_handle)) {
|
||||
return;
|
||||
}
|
||||
@ -508,18 +951,17 @@ void HTTP_C::GetResponseStatusCodeImpl(Kernel::HLERequestContext& ctx, bool time
|
||||
auto itr = contexts.find(context_handle);
|
||||
ASSERT(itr != contexts.end());
|
||||
|
||||
if (timeout) {
|
||||
itr->second.request_future.wait_for(std::chrono::nanoseconds(timeout));
|
||||
// TODO (flTobi): Return error on timeout
|
||||
} else {
|
||||
itr->second.request_future.wait();
|
||||
if (client_cert_id != 0x40) {
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(ERROR_WRONG_CERT_ID);
|
||||
return;
|
||||
}
|
||||
|
||||
const u32 response_code = itr->second.response.status;
|
||||
itr->second.uses_default_client_cert = true;
|
||||
itr->second.clcert_data = &GetClCertA();
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.Push(response_code);
|
||||
}
|
||||
|
||||
void HTTP_C::SetClientCertContext(Kernel::HLERequestContext& ctx) {
|
||||
@ -584,6 +1026,17 @@ void HTTP_C::GetSSLError(Kernel::HLERequestContext& ctx) {
|
||||
rb.Push<u32>(0);
|
||||
}
|
||||
|
||||
void HTTP_C::SetSSLOpt(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const u32 context_handle = rp.Pop<u32>();
|
||||
const u32 opts = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, context_handle={}, opts={}", context_handle, opts);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void HTTP_C::OpenClientCertContext(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
u32 cert_size = rp.Pop<u32>();
|
||||
@ -724,6 +1177,17 @@ void HTTP_C::CloseClientCertContext(Kernel::HLERequestContext& ctx) {
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void HTTP_C::SetKeepAlive(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
const u32 context_handle = rp.Pop<u32>();
|
||||
const u32 option = rp.Pop<u32>();
|
||||
|
||||
LOG_WARNING(Service_HTTP, "(STUBBED) called, handle={}, option={}", context_handle, option);
|
||||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
void HTTP_C::Finalize(Kernel::HLERequestContext& ctx) {
|
||||
IPC::RequestParser rp(ctx);
|
||||
|
||||
@ -763,9 +1227,11 @@ void HTTP_C::GetDownloadSizeState(Kernel::HLERequestContext& ctx) {
|
||||
}
|
||||
}
|
||||
|
||||
LOG_DEBUG(Service_HTTP, "current={}, total={}", itr->second.current_copied_data,
|
||||
content_length);
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(3, 0);
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.Push(content_length);
|
||||
rb.Push(static_cast<u32>(itr->second.current_copied_data));
|
||||
rb.Push(content_length);
|
||||
}
|
||||
|
||||
@ -895,7 +1361,7 @@ HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) {
|
||||
{0x0001, &HTTP_C::Initialize, "Initialize"},
|
||||
{0x0002, &HTTP_C::CreateContext, "CreateContext"},
|
||||
{0x0003, &HTTP_C::CloseContext, "CloseContext"},
|
||||
{0x0004, nullptr, "CancelConnection"},
|
||||
{0x0004, &HTTP_C::CancelConnection, "CancelConnection"},
|
||||
{0x0005, nullptr, "GetRequestState"},
|
||||
{0x0006, &HTTP_C::GetDownloadSizeState, "GetDownloadSizeState"},
|
||||
{0x0007, nullptr, "GetRequestError"},
|
||||
@ -905,13 +1371,13 @@ HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) {
|
||||
{0x000B, &HTTP_C::ReceiveData, "ReceiveData"},
|
||||
{0x000C, &HTTP_C::ReceiveDataTimeout, "ReceiveDataTimeout"},
|
||||
{0x000D, nullptr, "SetProxy"},
|
||||
{0x000E, nullptr, "SetProxyDefault"},
|
||||
{0x000E, &HTTP_C::SetProxyDefault, "SetProxyDefault"},
|
||||
{0x000F, nullptr, "SetBasicAuthorization"},
|
||||
{0x0010, nullptr, "SetSocketBufferSize"},
|
||||
{0x0011, &HTTP_C::AddRequestHeader, "AddRequestHeader"},
|
||||
{0x0012, &HTTP_C::AddPostDataAscii, "AddPostDataAscii"},
|
||||
{0x0013, nullptr, "AddPostDataBinary"},
|
||||
{0x0014, nullptr, "AddPostDataRaw"},
|
||||
{0x0014, &HTTP_C::AddPostDataRaw, "AddPostDataRaw"},
|
||||
{0x0015, nullptr, "SetPostDataType"},
|
||||
{0x0016, nullptr, "SendPostDataAscii"},
|
||||
{0x0017, nullptr, "SendPostDataAsciiTimeout"},
|
||||
@ -921,19 +1387,20 @@ HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) {
|
||||
{0x001B, nullptr, "SendPOSTDataRawTimeout"},
|
||||
{0x001C, nullptr, "SetPostDataEncoding"},
|
||||
{0x001D, nullptr, "NotifyFinishSendPostData"},
|
||||
{0x001E, nullptr, "GetResponseHeader"},
|
||||
{0x001E, &HTTP_C::GetResponseHeader, "GetResponseHeader"},
|
||||
{0x001F, nullptr, "GetResponseHeaderTimeout"},
|
||||
{0x0020, nullptr, "GetResponseData"},
|
||||
{0x0021, nullptr, "GetResponseDataTimeout"},
|
||||
{0x0022, &HTTP_C::GetResponseStatusCode, "GetResponseStatusCode"},
|
||||
{0x0023, &HTTP_C::GetResponseStatusCodeTimeout, "GetResponseStatusCodeTimeout"},
|
||||
{0x0024, nullptr, "AddTrustedRootCA"},
|
||||
{0x0025, nullptr, "AddDefaultCert"},
|
||||
{0x0024, &HTTP_C::AddTrustedRootCA, "AddTrustedRootCA"},
|
||||
{0x0025, &HTTP_C::AddDefaultCert, "AddDefaultCert"},
|
||||
{0x0026, nullptr, "SelectRootCertChain"},
|
||||
{0x0027, nullptr, "SetClientCert"},
|
||||
{0x0028, &HTTP_C::SetDefaultClientCert, "SetDefaultClientCert"},
|
||||
{0x0029, &HTTP_C::SetClientCertContext, "SetClientCertContext"},
|
||||
{0x002A, &HTTP_C::GetSSLError, "GetSSLError"},
|
||||
{0x002B, nullptr, "SetSSLOpt"},
|
||||
{0x002B, &HTTP_C::SetSSLOpt, "SetSSLOpt"},
|
||||
{0x002C, nullptr, "SetSSLClearOpt"},
|
||||
{0x002D, nullptr, "CreateRootCertChain"},
|
||||
{0x002E, nullptr, "DestroyRootCertChain"},
|
||||
@ -945,7 +1412,7 @@ HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) {
|
||||
{0x0034, &HTTP_C::CloseClientCertContext, "CloseClientCertContext"},
|
||||
{0x0035, nullptr, "SetDefaultProxy"},
|
||||
{0x0036, nullptr, "ClearDNSCache"},
|
||||
{0x0037, nullptr, "SetKeepAlive"},
|
||||
{0x0037, &HTTP_C::SetKeepAlive, "SetKeepAlive"},
|
||||
{0x0038, nullptr, "SetPostDataTypeSize"},
|
||||
{0x0039, &HTTP_C::Finalize, "Finalize"},
|
||||
// clang-format on
|
||||
@ -955,6 +1422,10 @@ HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) {
|
||||
DecryptClCertA();
|
||||
}
|
||||
|
||||
std::shared_ptr<HTTP_C> GetService(Core::System& system) {
|
||||
return system.ServiceManager().GetService<HTTP_C>("http:C");
|
||||
}
|
||||
|
||||
void InstallInterfaces(Core::System& system) {
|
||||
auto& service_manager = system.ServiceManager();
|
||||
std::make_shared<HTTP_C>()->InstallAsService(service_manager);
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include <ifaddrs.h>
|
||||
#endif
|
||||
#include <httplib.h>
|
||||
#include "core/hle/ipc_helpers.h"
|
||||
#include "core/hle/kernel/shared_memory.h"
|
||||
#include "core/hle/service/service.h"
|
||||
|
||||
@ -114,6 +115,12 @@ private:
|
||||
friend class boost::serialization::access;
|
||||
};
|
||||
|
||||
struct ClCertAData {
|
||||
std::vector<u8> certificate;
|
||||
std::vector<u8> private_key;
|
||||
bool init = false;
|
||||
};
|
||||
|
||||
/// Represents an HTTP context.
|
||||
class Context final {
|
||||
public:
|
||||
@ -169,22 +176,6 @@ public:
|
||||
friend class boost::serialization::access;
|
||||
};
|
||||
|
||||
struct PostData {
|
||||
// TODO(Subv): Support Binary and Raw POST elements.
|
||||
PostData(std::string name, std::string value) : name(name), value(value){};
|
||||
PostData() = default;
|
||||
std::string name;
|
||||
std::string value;
|
||||
|
||||
private:
|
||||
template <class Archive>
|
||||
void serialize(Archive& ar, const unsigned int) {
|
||||
ar& name;
|
||||
ar& value;
|
||||
}
|
||||
friend class boost::serialization::access;
|
||||
};
|
||||
|
||||
struct SSLConfig {
|
||||
u32 options;
|
||||
std::weak_ptr<ClientCertContext> client_cert_ctx;
|
||||
@ -210,11 +201,15 @@ public:
|
||||
SSLConfig ssl_config{};
|
||||
u32 socket_buffer_size;
|
||||
std::vector<RequestHeader> headers;
|
||||
std::vector<PostData> post_data;
|
||||
const ClCertAData* clcert_data;
|
||||
httplib::Params post_data;
|
||||
std::string post_data_raw;
|
||||
|
||||
std::future<void> request_future;
|
||||
std::atomic<u64> current_download_size_bytes;
|
||||
std::atomic<u64> total_download_size_bytes;
|
||||
size_t current_copied_data;
|
||||
bool uses_default_client_cert{};
|
||||
httplib::Response response;
|
||||
};
|
||||
|
||||
@ -252,6 +247,10 @@ class HTTP_C final : public ServiceFramework<HTTP_C, SessionData> {
|
||||
public:
|
||||
HTTP_C();
|
||||
|
||||
const ClCertAData& GetClCertA() const {
|
||||
return ClCertA;
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* HTTP_C::Initialize service function
|
||||
@ -288,6 +287,15 @@ private:
|
||||
*/
|
||||
void CloseContext(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::CancelConnection service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void CancelConnection(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::GetDownloadSizeState service function
|
||||
* Inputs:
|
||||
@ -328,6 +336,15 @@ private:
|
||||
*/
|
||||
void BeginRequestAsync(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::SetProxyDefault service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void SetProxyDefault(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::ReceiveData service function
|
||||
* Inputs:
|
||||
@ -389,6 +406,33 @@ private:
|
||||
*/
|
||||
void AddPostDataAscii(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::AddPostDataRaw service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* 2 : Post data length
|
||||
* 3-4: (Mapped buffer) Post data
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
* 2-3: (Mapped buffer) Post data
|
||||
*/
|
||||
void AddPostDataRaw(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::GetResponseHeader service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* 2 : Header name length
|
||||
* 3 : Return value length
|
||||
* 4-5 : (Static buffer) Header name
|
||||
* 6-7 : (Mapped buffer) Header value
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
* 2 : Header value copied size
|
||||
* 3-4: (Mapped buffer) Header value
|
||||
*/
|
||||
void GetResponseHeader(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::GetResponseStatusCode service function
|
||||
* Inputs:
|
||||
@ -410,12 +454,44 @@ private:
|
||||
*/
|
||||
void GetResponseStatusCodeTimeout(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::AddTrustedRootCA service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* 2 : CA data length
|
||||
* 3-4: (Mapped buffer) CA data
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
* 2-3: (Mapped buffer) CA data
|
||||
*/
|
||||
void AddTrustedRootCA(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::AddDefaultCert service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* 2 : Cert ID
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void AddDefaultCert(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* GetResponseStatusCodeImpl:
|
||||
* Implements GetResponseStatusCode and GetResponseStatusCodeTimeout service functions
|
||||
*/
|
||||
void GetResponseStatusCodeImpl(Kernel::HLERequestContext& ctx, bool timeout);
|
||||
|
||||
/**
|
||||
* HTTP_C::SetDefaultClientCert service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* 2 : Client cert ID
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void SetDefaultClientCert(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::SetClientCertContext service function
|
||||
* Inputs:
|
||||
@ -437,6 +513,16 @@ private:
|
||||
*/
|
||||
void GetSSLError(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::SetSSLOpt service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* 2 : SSL Option
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void SetSSLOpt(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::OpenClientCertContext service function
|
||||
* Inputs:
|
||||
@ -470,6 +556,16 @@ private:
|
||||
*/
|
||||
void CloseClientCertContext(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::SetKeepAlive service function
|
||||
* Inputs:
|
||||
* 1 : Context handle
|
||||
* 2 : Keep Alive Option
|
||||
* Outputs:
|
||||
* 1 : Result of function, 0 on success, otherwise error code
|
||||
*/
|
||||
void SetKeepAlive(Kernel::HLERequestContext& ctx);
|
||||
|
||||
/**
|
||||
* HTTP_C::Finalize service function
|
||||
* Outputs:
|
||||
@ -502,11 +598,7 @@ private:
|
||||
/// Global list of ClientCert contexts currently opened.
|
||||
std::unordered_map<ClientCertContext::Handle, std::shared_ptr<ClientCertContext>> client_certs;
|
||||
|
||||
struct {
|
||||
std::vector<u8> certificate;
|
||||
std::vector<u8> private_key;
|
||||
bool init = false;
|
||||
} ClCertA;
|
||||
ClCertAData ClCertA;
|
||||
|
||||
private:
|
||||
template <class Archive>
|
||||
@ -527,6 +619,8 @@ private:
|
||||
friend class boost::serialization::access;
|
||||
};
|
||||
|
||||
std::shared_ptr<HTTP_C> GetService(Core::System& system);
|
||||
|
||||
void InstallInterfaces(Core::System& system);
|
||||
|
||||
} // namespace Service::HTTP
|
||||
|
||||
Loading…
Reference in New Issue
Block a user