2014-12-21 20:52:10 +01:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-07-22 01:48:57 +02:00
|
|
|
#include "core/hle/ipc_helpers.h"
|
|
|
|
#include "core/hle/kernel/ipc.h"
|
2014-12-21 20:52:10 +01:00
|
|
|
#include "core/hle/service/http_c.h"
|
|
|
|
|
2016-12-10 13:51:50 +01:00
|
|
|
namespace Service {
|
|
|
|
namespace HTTP {
|
2014-12-21 20:52:10 +01:00
|
|
|
|
2018-07-22 02:50:13 +02:00
|
|
|
namespace ErrCodes {
|
|
|
|
enum {
|
2018-07-25 21:59:29 +02:00
|
|
|
TooManyContexts = 26,
|
2018-07-22 02:50:13 +02:00
|
|
|
InvalidRequestMethod = 32,
|
2018-07-25 23:13:47 +02:00
|
|
|
ContextNotFound = 100,
|
2018-07-25 21:59:29 +02:00
|
|
|
|
|
|
|
/// This error is returned in multiple situations: when trying to initialize an
|
|
|
|
/// already-initialized session, or when using the wrong context handle in a context-bound
|
|
|
|
/// session
|
|
|
|
SessionStateError = 102,
|
2018-07-22 02:50:13 +02:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
const ResultCode ERROR_STATE_ERROR = // 0xD8A0A066
|
|
|
|
ResultCode(ErrCodes::SessionStateError, ErrorModule::HTTP, ErrorSummary::InvalidState,
|
2018-07-22 02:50:13 +02:00
|
|
|
ErrorLevel::Permanent);
|
|
|
|
|
2018-07-22 01:54:06 +02:00
|
|
|
void HTTP_C::Initialize(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp(ctx, 0x1, 1, 4);
|
|
|
|
const u32 shmem_size = rp.Pop<u32>();
|
2018-07-25 23:13:47 +02:00
|
|
|
u32 pid = rp.PopPID();
|
2018-07-22 01:54:06 +02:00
|
|
|
shared_memory = rp.PopObject<Kernel::SharedMemory>();
|
|
|
|
if (shared_memory) {
|
|
|
|
shared_memory->name = "HTTP_C:shared_memory";
|
|
|
|
}
|
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
LOG_WARNING(Service_HTTP, "(STUBBED) called, shared memory size: {}", shmem_size);
|
|
|
|
|
|
|
|
auto* session_data = GetSessionData(ctx.Session());
|
|
|
|
ASSERT(session_data);
|
|
|
|
|
|
|
|
if (session_data->initialized) {
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
|
|
|
rb.Push(ERROR_STATE_ERROR);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
session_data->initialized = true;
|
|
|
|
|
2018-07-22 01:54:06 +02:00
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
|
|
|
// This returns 0xd8a0a046 if no network connection is available.
|
|
|
|
// Just assume we are always connected.
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
2018-07-25 23:13:47 +02:00
|
|
|
void HTTP_C::InitializeConnectionSession(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp(ctx, 0x8, 1, 2);
|
|
|
|
const u32 context_handle = rp.Pop<u32>();
|
|
|
|
u32 pid = rp.PopPID();
|
|
|
|
|
|
|
|
auto* session_data = GetSessionData(ctx.Session());
|
|
|
|
ASSERT(session_data);
|
|
|
|
|
|
|
|
if (session_data->initialized) {
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
|
|
|
rb.Push(ERROR_STATE_ERROR);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(Subv): Check that the input PID matches the PID that created the context.
|
|
|
|
auto itr = contexts.find(context_handle);
|
|
|
|
if (itr == contexts.end()) {
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
|
|
|
rb.Push(ResultCode(ErrCodes::ContextNotFound, ErrorModule::HTTP, ErrorSummary::InvalidState,
|
|
|
|
ErrorLevel::Permanent));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
session_data->initialized = true;
|
|
|
|
// Bind the context to the current session.
|
|
|
|
session_data->current_http_context = context_handle;
|
|
|
|
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
LOG_DEBUG(Service_HTTP, "called, context_id={}", context_handle);
|
|
|
|
}
|
|
|
|
|
2018-07-22 02:30:40 +02:00
|
|
|
void HTTP_C::CreateContext(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp(ctx, 0x2, 2, 2);
|
|
|
|
const u32 url_size = rp.Pop<u32>();
|
|
|
|
RequestMethod method = rp.PopEnum<RequestMethod>();
|
|
|
|
Kernel::MappedBuffer& buffer = rp.PopMappedBuffer();
|
2018-07-23 21:14:41 +02:00
|
|
|
|
|
|
|
// Copy the buffer into a string without the \0 at the end of the buffer
|
|
|
|
std::string url(url_size, '\0');
|
2018-07-22 02:30:40 +02:00
|
|
|
buffer.Read(&url[0], 0, url_size - 1);
|
|
|
|
|
|
|
|
LOG_DEBUG(Service_HTTP, "called, url_size={}, url={}, method={}", url_size, url,
|
|
|
|
static_cast<u32>(method));
|
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
auto* session_data = GetSessionData(ctx.Session());
|
|
|
|
ASSERT(session_data);
|
|
|
|
|
2018-07-25 23:13:47 +02:00
|
|
|
if (!session_data->initialized) {
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
|
|
|
rb.Push(ERROR_STATE_ERROR);
|
|
|
|
rb.PushMappedBuffer(buffer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
// This command can only be called without a bound session.
|
|
|
|
if (session_data->current_http_context != boost::none) {
|
|
|
|
LOG_ERROR(Service_HTTP, "Command called with a bound context");
|
|
|
|
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
|
|
|
rb.Push(ResultCode(ErrorDescription::NotImplemented, ErrorModule::HTTP,
|
|
|
|
ErrorSummary::Internal, ErrorLevel::Permanent));
|
|
|
|
rb.PushMappedBuffer(buffer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static constexpr size_t MaxConcurrentHTTPContexts = 8;
|
|
|
|
if (session_data->num_http_contexts >= MaxConcurrentHTTPContexts) {
|
|
|
|
// There can only be 8 HTTP contexts open at the same time for any particular session.
|
|
|
|
LOG_ERROR(Service_HTTP, "Tried to open too many HTTP contexts");
|
|
|
|
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
|
|
|
rb.Push(ResultCode(ErrCodes::TooManyContexts, ErrorModule::HTTP, ErrorSummary::InvalidState,
|
|
|
|
ErrorLevel::Permanent));
|
|
|
|
rb.PushMappedBuffer(buffer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-07-22 02:50:13 +02:00
|
|
|
if (method == RequestMethod::None || static_cast<u32>(method) >= TotalRequestMethods) {
|
|
|
|
LOG_ERROR(Service_HTTP, "invalid request method={}", static_cast<u32>(method));
|
|
|
|
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
2018-07-25 21:59:29 +02:00
|
|
|
rb.Push(ResultCode(ErrCodes::InvalidRequestMethod, ErrorModule::HTTP,
|
|
|
|
ErrorSummary::InvalidState, ErrorLevel::Permanent));
|
2018-07-22 02:50:13 +02:00
|
|
|
rb.PushMappedBuffer(buffer);
|
|
|
|
return;
|
|
|
|
}
|
2018-07-22 02:30:40 +02:00
|
|
|
|
2018-07-23 18:02:35 +02:00
|
|
|
contexts.emplace(++context_counter, Context());
|
2018-07-22 18:14:23 +02:00
|
|
|
contexts[context_counter].url = std::move(url);
|
|
|
|
contexts[context_counter].method = method;
|
|
|
|
contexts[context_counter].state = RequestState::NotStarted;
|
2018-07-22 02:30:40 +02:00
|
|
|
// TODO(Subv): Find a correct default value for this field.
|
2018-07-22 18:14:23 +02:00
|
|
|
contexts[context_counter].socket_buffer_size = 0;
|
2018-07-23 18:02:35 +02:00
|
|
|
contexts[context_counter].handle = context_counter;
|
2018-07-22 02:30:40 +02:00
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
session_data->num_http_contexts++;
|
|
|
|
|
2018-07-22 02:30:40 +02:00
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(2, 2);
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.Push<u32>(context_counter);
|
|
|
|
rb.PushMappedBuffer(buffer);
|
|
|
|
}
|
|
|
|
|
2018-07-22 03:11:20 +02:00
|
|
|
void HTTP_C::CloseContext(Kernel::HLERequestContext& ctx) {
|
2018-07-23 21:14:41 +02:00
|
|
|
IPC::RequestParser rp(ctx, 0x3, 1, 0);
|
2018-07-22 03:11:20 +02:00
|
|
|
|
|
|
|
u32 context_handle = rp.Pop<u32>();
|
|
|
|
|
|
|
|
LOG_WARNING(Service_HTTP, "(STUBBED) called, handle={}", context_handle);
|
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
auto* session_data = GetSessionData(ctx.Session());
|
|
|
|
ASSERT(session_data);
|
|
|
|
|
2018-07-25 23:13:47 +02:00
|
|
|
if (!session_data->initialized) {
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
|
|
|
rb.Push(ERROR_STATE_ERROR);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
ASSERT_MSG(session_data->current_http_context == boost::none,
|
|
|
|
"Unimplemented CloseContext on context-bound session");
|
|
|
|
|
2018-07-22 03:11:20 +02:00
|
|
|
auto itr = contexts.find(context_handle);
|
|
|
|
if (itr == contexts.end()) {
|
2018-07-25 21:59:29 +02:00
|
|
|
// The real HTTP module just silently fails in this case.
|
2018-07-22 03:11:20 +02:00
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
2018-07-25 21:59:29 +02:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
2018-07-22 03:11:20 +02:00
|
|
|
LOG_ERROR(Service_HTTP, "called, context {} not found", context_handle);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(Subv): What happens if you try to close a context that's currently being used?
|
|
|
|
ASSERT(itr->second.state == RequestState::NotStarted);
|
|
|
|
|
2018-07-25 21:59:29 +02:00
|
|
|
// TODO(Subv): Make sure that only the session that created the context can close it.
|
|
|
|
|
2018-07-22 03:11:20 +02:00
|
|
|
contexts.erase(itr);
|
2018-07-25 21:59:29 +02:00
|
|
|
session_data->num_http_contexts--;
|
2018-07-22 03:11:20 +02:00
|
|
|
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
2018-07-22 12:15:03 +02:00
|
|
|
void HTTP_C::AddRequestHeader(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp(ctx, 0x11, 3, 4);
|
|
|
|
const u32 context_handle = rp.Pop<u32>();
|
|
|
|
const u32 name_size = rp.Pop<u32>();
|
|
|
|
const u32 value_size = rp.Pop<u32>();
|
|
|
|
const std::vector<u8> name_buffer = rp.PopStaticBuffer();
|
|
|
|
Kernel::MappedBuffer& value_buffer = rp.PopMappedBuffer();
|
2018-07-23 21:14:41 +02:00
|
|
|
|
|
|
|
// Copy the name_buffer into a string without the \0 at the end
|
2018-07-22 12:15:03 +02:00
|
|
|
const std::string name(name_buffer.begin(), name_buffer.end() - 1);
|
2018-07-23 21:14:41 +02:00
|
|
|
|
|
|
|
// Copy thr value_buffer into a string without the \0 at the end
|
2018-07-22 12:15:03 +02:00
|
|
|
std::string value(value_size - 1, '\0');
|
|
|
|
value_buffer.Read(&value[0], 0, value_size - 1);
|
|
|
|
|
|
|
|
auto itr = contexts.find(context_handle);
|
|
|
|
if (itr == contexts.end()) {
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
2018-07-25 21:59:29 +02:00
|
|
|
rb.Push(ERROR_STATE_ERROR);
|
2018-07-22 12:15:03 +02:00
|
|
|
LOG_ERROR(Service_HTTP, "called, context {} not found", context_handle);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(itr->second.state == RequestState::NotStarted);
|
|
|
|
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());
|
|
|
|
|
2018-07-22 15:10:43 +02:00
|
|
|
itr->second.headers.emplace_back(name, value);
|
2018-07-22 12:15:03 +02:00
|
|
|
|
|
|
|
IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.PushMappedBuffer(value_buffer);
|
|
|
|
|
|
|
|
LOG_WARNING(Service_HTTP, "called, name={}, value={}, context_handle={}", name, value,
|
|
|
|
context_handle);
|
|
|
|
}
|
|
|
|
|
2018-07-22 01:48:57 +02:00
|
|
|
HTTP_C::HTTP_C() : ServiceFramework("http:C", 32) {
|
|
|
|
static const FunctionInfo functions[] = {
|
2018-07-22 01:54:06 +02:00
|
|
|
{0x00010044, &HTTP_C::Initialize, "Initialize"},
|
2018-07-22 02:30:40 +02:00
|
|
|
{0x00020082, &HTTP_C::CreateContext, "CreateContext"},
|
2018-07-22 03:11:20 +02:00
|
|
|
{0x00030040, &HTTP_C::CloseContext, "CloseContext"},
|
2018-07-22 01:48:57 +02:00
|
|
|
{0x00040040, nullptr, "CancelConnection"},
|
|
|
|
{0x00050040, nullptr, "GetRequestState"},
|
|
|
|
{0x00060040, nullptr, "GetDownloadSizeState"},
|
|
|
|
{0x00070040, nullptr, "GetRequestError"},
|
2018-07-25 23:13:47 +02:00
|
|
|
{0x00080042, &HTTP_C::InitializeConnectionSession, "InitializeConnectionSession"},
|
2018-07-22 01:48:57 +02:00
|
|
|
{0x00090040, nullptr, "BeginRequest"},
|
|
|
|
{0x000A0040, nullptr, "BeginRequestAsync"},
|
|
|
|
{0x000B0082, nullptr, "ReceiveData"},
|
|
|
|
{0x000C0102, nullptr, "ReceiveDataTimeout"},
|
|
|
|
{0x000D0146, nullptr, "SetProxy"},
|
|
|
|
{0x000E0040, nullptr, "SetProxyDefault"},
|
|
|
|
{0x000F00C4, nullptr, "SetBasicAuthorization"},
|
|
|
|
{0x00100080, nullptr, "SetSocketBufferSize"},
|
2018-07-22 12:15:03 +02:00
|
|
|
{0x001100C4, &HTTP_C::AddRequestHeader, "AddRequestHeader"},
|
2018-07-22 01:48:57 +02:00
|
|
|
{0x001200C4, nullptr, "AddPostDataAscii"},
|
|
|
|
{0x001300C4, nullptr, "AddPostDataBinary"},
|
|
|
|
{0x00140082, nullptr, "AddPostDataRaw"},
|
|
|
|
{0x00150080, nullptr, "SetPostDataType"},
|
|
|
|
{0x001600C4, nullptr, "SendPostDataAscii"},
|
|
|
|
{0x00170144, nullptr, "SendPostDataAsciiTimeout"},
|
|
|
|
{0x001800C4, nullptr, "SendPostDataBinary"},
|
|
|
|
{0x00190144, nullptr, "SendPostDataBinaryTimeout"},
|
|
|
|
{0x001A0082, nullptr, "SendPostDataRaw"},
|
|
|
|
{0x001B0102, nullptr, "SendPOSTDataRawTimeout"},
|
|
|
|
{0x001C0080, nullptr, "SetPostDataEncoding"},
|
|
|
|
{0x001D0040, nullptr, "NotifyFinishSendPostData"},
|
|
|
|
{0x001E00C4, nullptr, "GetResponseHeader"},
|
|
|
|
{0x001F0144, nullptr, "GetResponseHeaderTimeout"},
|
|
|
|
{0x00200082, nullptr, "GetResponseData"},
|
|
|
|
{0x00210102, nullptr, "GetResponseDataTimeout"},
|
|
|
|
{0x00220040, nullptr, "GetResponseStatusCode"},
|
|
|
|
{0x002300C0, nullptr, "GetResponseStatusCodeTimeout"},
|
|
|
|
{0x00240082, nullptr, "AddTrustedRootCA"},
|
|
|
|
{0x00250080, nullptr, "AddDefaultCert"},
|
|
|
|
{0x00260080, nullptr, "SelectRootCertChain"},
|
|
|
|
{0x002700C4, nullptr, "SetClientCert"},
|
|
|
|
{0x00290080, nullptr, "SetClientCertContext"},
|
|
|
|
{0x002A0040, nullptr, "GetSSLError"},
|
|
|
|
{0x002B0080, nullptr, "SetSSLOpt"},
|
|
|
|
{0x002C0080, nullptr, "SetSSLClearOpt"},
|
|
|
|
{0x002D0000, nullptr, "CreateRootCertChain"},
|
|
|
|
{0x002E0040, nullptr, "DestroyRootCertChain"},
|
|
|
|
{0x002F0082, nullptr, "RootCertChainAddCert"},
|
|
|
|
{0x00300080, nullptr, "RootCertChainAddDefaultCert"},
|
|
|
|
{0x00310080, nullptr, "RootCertChainRemoveCert"},
|
|
|
|
{0x00320084, nullptr, "OpenClientCertContext"},
|
|
|
|
{0x00330040, nullptr, "OpenDefaultClientCertContext"},
|
|
|
|
{0x00340040, nullptr, "CloseClientCertContext"},
|
|
|
|
{0x00350186, nullptr, "SetDefaultProxy"},
|
|
|
|
{0x00360000, nullptr, "ClearDNSCache"},
|
|
|
|
{0x00370080, nullptr, "SetKeepAlive"},
|
|
|
|
{0x003800C0, nullptr, "SetPostDataTypeSize"},
|
|
|
|
{0x00390000, nullptr, "Finalize"},
|
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
2014-12-21 20:52:10 +01:00
|
|
|
}
|
|
|
|
|
2018-07-22 01:48:57 +02:00
|
|
|
void InstallInterfaces(SM::ServiceManager& service_manager) {
|
|
|
|
std::make_shared<HTTP_C>()->InstallAsService(service_manager);
|
|
|
|
}
|
2016-12-10 13:51:50 +01:00
|
|
|
} // namespace HTTP
|
|
|
|
} // namespace Service
|