Atmosphere/stratosphere/sm/source/impl/sm_service_manager.cpp

958 lines
36 KiB
C++
Raw Normal View History

2019-06-21 01:23:40 +00:00
/*
* Copyright (c) Atmosphère-NX
2019-06-21 01:23:40 +00:00
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
2019-06-21 01:23:40 +00:00
#include "sm_service_manager.hpp"
#include "../sm_wait_list.hpp"
2019-06-21 01:23:40 +00:00
namespace ams::hos {
void InitializeVersionInternal(bool allow_approximate);
}
namespace ams::sm::impl {
2019-06-21 01:23:40 +00:00
namespace {
2019-06-21 01:23:40 +00:00
/* Constexpr definitions. */
static constexpr size_t ProcessCountMax = 0x50;
static constexpr size_t ServiceCountMax = 0x180;
static constexpr size_t MitmCountMax = 0x20;
2019-06-21 01:23:40 +00:00
static constexpr size_t AccessControlSizeMax = 0x200;
constexpr const sm::ServiceName InitiallyDeferredServices[] = {
ServiceName::Encode("fsp-srv")
};
2019-06-21 01:23:40 +00:00
/* Types. */
struct ProcessInfo {
os::ProcessId process_id;
ncm::ProgramId program_id;
cfg::OverrideStatus override_status;
2019-06-21 01:23:40 +00:00
size_t access_control_size;
u8 access_control[AccessControlSizeMax];
};
constexpr const ProcessInfo InvalidProcessInfo = {
.process_id = os::InvalidProcessId,
.program_id = ncm::InvalidProgramId,
.override_status = {},
.access_control_size = 0,
.access_control = {},
};
2019-06-21 01:23:40 +00:00
struct ServiceInfo {
ServiceName name;
os::ProcessId owner_process_id;
os::NativeHandle port_h;
bool is_light;
u8 max_sessions;
u8 mitm_index;
};
2019-06-21 06:34:59 +00:00
struct MitmInfo {
os::ProcessId process_id;
os::ProcessId waiting_ack_process_id;
os::NativeHandle port_h;
os::NativeHandle query_h;
os::NativeHandle fwd_sess_h;
bool waiting_ack;
};
constexpr const ServiceInfo InvalidServiceInfo = {
.name = sm::InvalidServiceName,
.owner_process_id = os::InvalidProcessId,
.port_h = os::InvalidNativeHandle,
.is_light = false,
.max_sessions = 0,
.mitm_index = MitmCountMax,
};
constexpr const MitmInfo InvalidMitmInfo = {
.process_id = os::InvalidProcessId,
.waiting_ack_process_id = os::InvalidProcessId,
.port_h = os::InvalidNativeHandle,
.query_h = os::InvalidNativeHandle,
.fwd_sess_h = os::InvalidNativeHandle,
.waiting_ack = false,
2019-06-21 01:23:40 +00:00
};
class AccessControlEntry {
private:
const u8 *m_entry;
size_t m_capacity;
2019-06-21 01:23:40 +00:00
public:
AccessControlEntry(const void *e, size_t c) : m_entry(static_cast<const u8 *>(e)), m_capacity(c) {
2019-06-21 01:23:40 +00:00
/* ... */
}
AccessControlEntry GetNextEntry() const {
return AccessControlEntry(m_entry + this->GetSize(), m_capacity - this->GetSize());
2019-06-21 01:23:40 +00:00
}
size_t GetSize() const {
return this->GetServiceNameSize() + 1;
}
size_t GetServiceNameSize() const {
return (m_entry[0] & 7) + 1;
2019-06-21 01:23:40 +00:00
}
ServiceName GetServiceName() const {
return ServiceName::Encode(reinterpret_cast<const char *>(m_entry + 1), this->GetServiceNameSize());
2019-06-21 01:23:40 +00:00
}
bool IsHost() const {
return (m_entry[0] & 0x80) != 0;
2019-06-21 01:23:40 +00:00
}
bool IsWildcard() const {
return m_entry[this->GetServiceNameSize()] == '*';
2019-06-21 01:23:40 +00:00
}
bool IsValid() const {
/* Validate that we can access data. */
if (m_entry == nullptr || m_capacity == 0) {
2019-06-21 01:23:40 +00:00
return false;
}
/* Validate that the size is correct. */
return this->GetSize() <= m_capacity;
2019-06-21 01:23:40 +00:00
}
};
class InitialProcessIdLimits {
private:
2021-10-10 07:14:06 +00:00
os::ProcessId m_min;
os::ProcessId m_max;
2019-06-21 01:23:40 +00:00
public:
InitialProcessIdLimits() {
/* Retrieve process limits. */
2021-10-12 07:20:21 +00:00
R_ABORT_UNLESS(svc::GetSystemInfo(std::addressof(m_min.value), svc::SystemInfoType_InitialProcessIdRange, svc::InvalidHandle, svc::InitialProcessIdRangeInfo_Minimum));
R_ABORT_UNLESS(svc::GetSystemInfo(std::addressof(m_max.value), svc::SystemInfoType_InitialProcessIdRange, svc::InvalidHandle, svc::InitialProcessIdRangeInfo_Maximum));
2019-06-21 01:23:40 +00:00
/* Ensure range is sane. */
2021-10-10 07:14:06 +00:00
AMS_ABORT_UNLESS(m_min <= m_max);
2019-06-21 01:23:40 +00:00
}
bool IsInitialProcess(os::ProcessId process_id) const {
2020-02-23 07:05:14 +00:00
AMS_ABORT_UNLESS(process_id != os::InvalidProcessId);
2021-10-10 07:14:06 +00:00
return m_min <= process_id && process_id <= m_max;
2019-06-21 01:23:40 +00:00
}
};
/* Static members. */
/* NOTE: In 12.0.0, Nintendo added multithreaded processing to sm; however, official sm does not do */
/* any kind of mutual exclusivity when accessing (and modifying) global state. Previously, this was */
/* not a problem, because sm was strictly single-threaded, and so two threads could not race eachother. */
/* We will add a mutex (and perform locking) in order to prevent simultaneous access to global state. */
constinit os::SdkRecursiveMutex g_mutex;
constinit std::array<ProcessInfo, ProcessCountMax> g_process_list = [] {
std::array<ProcessInfo, ProcessCountMax> list = {};
/* Initialize each info. */
for (auto &process_info : list) {
process_info = InvalidProcessInfo;
2019-06-21 01:23:40 +00:00
}
return list;
}();
2019-06-21 06:34:59 +00:00
constinit std::array<ServiceInfo, ServiceCountMax> g_service_list = [] {
std::array<ServiceInfo, ServiceCountMax> list = {};
/* Initialize each info. */
for (auto &service_info : list) {
service_info = InvalidServiceInfo;
}
return list;
}();
constinit std::array<ServiceName, MitmCountMax> g_future_mitm_list = [] {
std::array<ServiceName, MitmCountMax> list = {};
/* Initialize each info. */
for (auto &name : list) {
name = InvalidServiceName;
}
return list;
}();
constinit std::array<MitmInfo, MitmCountMax> g_mitm_list = [] {
std::array<MitmInfo, MitmCountMax> list = {};
/* Initialize each info. */
for (auto &mitm_info : list) {
mitm_info = InvalidMitmInfo;
}
return list;
}();
constinit bool g_ended_initial_defers = false;
const InitialProcessIdLimits g_initial_process_id_limits;
/* Helper functionality. */
bool IsInitialProcess(os::ProcessId process_id) {
return g_initial_process_id_limits.IsInitialProcess(process_id);
}
constexpr inline bool IsValidProcessId(os::ProcessId process_id) {
return process_id != os::InvalidProcessId;
2019-06-21 01:23:40 +00:00
}
Result ValidateAccessControl(AccessControlEntry access_control, ServiceName service, bool is_host, bool is_wildcard) {
/* Iterate over all entries in the access control, checking to see if we have a match. */
while (access_control.IsValid()) {
if (access_control.IsHost() == is_host) {
bool is_valid = true;
2019-06-21 01:23:40 +00:00
if (access_control.IsWildcard() == is_wildcard) {
/* Check for exact match. */
is_valid &= access_control.GetServiceName() == service;
2019-06-21 01:23:40 +00:00
} else if (access_control.IsWildcard()) {
/* Also allow fuzzy match for wildcard. */
ServiceName ac_service = access_control.GetServiceName();
is_valid &= std::memcmp(std::addressof(ac_service), std::addressof(service), access_control.GetServiceNameSize() - 1) == 0;
2019-06-21 01:23:40 +00:00
}
Implement the NCM sysmodule (closes #91) * Implement NCM * Modernize ncm_main * Remove unnecessary smExit * Give access to svcCallSecureMonitor * Stack size bump * Fix incorrect setup for NandUser's content storage entry * Fix a potential data abort when flushing the placeholder accessor cache * Fix HasFile and HasDirectory * Use r+b, not w+b * Misc fixes * errno begone * Fixed more stdio error handling * More main fixes * Various command improvements * Make dispatch tables great again * Fix logic inversion * Fixed content path generation * Bump heap size, fix CleanupAllPlaceHolder * Various fixes. Note: This contains debug stuff which will be removed later. I was getting tired of having to cherrypick tiny changes * Fixed placeholder/content deletion * Fixed incorrect content manager destruction * Prevent automatic placeholder creation on open * Fixed List implementation. Also lots of debug logging. * Removed debug code * Added a scope guard for WritePlaceHolder * Manually prevent placeholder/content appending * Revert "Removed debug code" This reverts commit d6ff261fcc8c1f26968e894b02c17a01a12ec98b. * Always cache placeholder file. Switch to ftell for preventing appending * Universally use EnsureEnabled * Abstract away file writing logic * Misc cleanup * Refactor placeholder cacheing * Remove debug code (again) * Revert "Remove debug code (again)" This reverts commit 168447d80e9640768fb1b43f04a385507c1bb5ab. * Misc changes * Fixed file modes * Fixed ContentId/PlaceHolderId alignment * Improved type safety * Fixed reinitialization * Fixed doubleup on path creation * Remove debug code * Fixed 1.0.0 booting * Correct amount of add on content * Correct main thread stack size * lr: Introducing registered data * Reorder stratosphere Makefile * Move results to libstrat * lr: Cleanup lr_redirection * lr: lr_manager tweaks * lr: Imrpoved path handling and adjust ResolveAddOnContentPath order * lr: Organise types * Add eof newlines * lr: Eliminate unnecessary vars * lr: Unnecessary vars 2 electric boogaloo * lr: Various helpers * lr: RegisteredLocationResolver helpers * ncm: Move ncm_types to libstrat * ncm: Misc cleanup * Implement NCM * Modernize ncm_main * Remove unnecessary smExit * Give access to svcCallSecureMonitor * Stack size bump * Fix incorrect setup for NandUser's content storage entry * Fix a potential data abort when flushing the placeholder accessor cache * Fix HasFile and HasDirectory * Use r+b, not w+b * Misc fixes * errno begone * Fixed more stdio error handling * More main fixes * Various command improvements * Make dispatch tables great again * Fix logic inversion * Fixed content path generation * Bump heap size, fix CleanupAllPlaceHolder * Various fixes. Note: This contains debug stuff which will be removed later. I was getting tired of having to cherrypick tiny changes * Fixed placeholder/content deletion * Fixed incorrect content manager destruction * Prevent automatic placeholder creation on open * Fixed List implementation. Also lots of debug logging. * Removed debug code * Added a scope guard for WritePlaceHolder * Manually prevent placeholder/content appending * Revert "Removed debug code" This reverts commit d6ff261fcc8c1f26968e894b02c17a01a12ec98b. * Always cache placeholder file. Switch to ftell for preventing appending * Universally use EnsureEnabled * Abstract away file writing logic * Misc cleanup * Refactor placeholder cacheing * Remove debug code (again) * Revert "Remove debug code (again)" This reverts commit 168447d80e9640768fb1b43f04a385507c1bb5ab. * Misc changes * Fixed file modes * Fixed ContentId/PlaceHolderId alignment * Improved type safety * Fixed reinitialization * Fixed doubleup on path creation * Remove debug code * Fixed 1.0.0 booting * Correct amount of add on content * Correct main thread stack size * lr: Introducing registered data * Reorder stratosphere Makefile * Move results to libstrat * lr: Cleanup lr_redirection * lr: lr_manager tweaks * lr: Imrpoved path handling and adjust ResolveAddOnContentPath order * lr: Organise types * Add eof newlines * lr: Eliminate unnecessary vars * lr: Unnecessary vars 2 electric boogaloo * lr: Various helpers * lr: RegisteredLocationResolver helpers * ncm: Move ncm_types to libstrat * ncm: Misc cleanup * Updated AddOnContentLocationResolver and RegisteredLocationResolver to 9.0.0 * Finished updating lr to 9.0.0 * Updated NCM to 9.0.0 * Fix libstrat includes * Fixed application launching * title_id_2 -> owner_tid * Updated to new-ipc * Change to using pure virtuals * Title Id -> Program Id * Fixed compilation against master * std::scoped_lock<> -> std::scoped_lock * Adopted R_UNLESS and R_CONVERT * Prefix namespace to Results * Adopt std::numeric_limits * Fixed incorrect error handling in ReadFile * Adopted AMS_ABORT_UNLESS * Adopt util::GenerateUuid() * Syntax improvements * ncm_types: Address review * Address more review comments * Updated copyrights * Address more feedback * More feedback addressed * More changes * Move dispatch tables out of interface files * Addressed remaining comments * lr: move into libstratosphere * ncm: Fix logic inversion * lr: Add comments * lr: Remove whitespace * ncm: Start addressing feedback * ncm: Cleanup InitializeContentManager * lr: support client-side usage * lr_service -> lr_api * ncm: Begin refactoring content manager * ncm: More content manager improvements * ncm: Content manager mount improvements * ldr: use lr bindings * lr bindings usage: minor fixes * ncm/lr: Pointer placement * ncm: placeholder accessor cleanup * ncm: minor fixes * ncm: refactor rights cache * ncm: content meta database cleanup * ncm: move content meta database impl out of interface file * ncm: Use const ContentMetaKey & * ncm: fix other non-const ContentMetaKey references * ncm: content meta database cleanup * ncm: content storage fixes for 2.0.0 * ncm: add missing end of file newlines * ncm: implement ContentMetaReader * ncm: client-side api * ncm: trim trailing spaces * ncm: FS_MAX_PATH-1 -> fs::EntryNameLengthMax * ncm: Use PathString and Path * fs: implement accessor wrappers for ncm * fs: implement user fs wrappers * fs: add MountSdCard * ncm: move to content manager impl * ncm: fix up main * kvdb: use fs:: * fs: Add wrappers needed for ncm * ncm: use fs bindings, other refactoring * ncm: minor fixes * fsa: fix ReadFile without size output * fs: add substorage, rom path tool * ncm: fix dangling fsdev usage * fs: fix bug in Commit * fs: fixed incorrect mode check * fs: implement Mount(System)Data * ncm: don't delete hos * results: add R_SUCCEED_IF * ams-except-ncm: use R_SUCCEED_IF * ncm: added comments * ncm: fix api definitions * ncm: use R_SUCCEED_IF * pm: think of the savings * ncm: employ kernel strats * ncm: Nintendo has 5 MiB of heap. Give ourselves 4 to be safe, pending analysis * ncm: refactor IDs, split types header into many headers * ams.mitm: use fs bindings instead of stdio * fs: SystemData uses SystemDataId * ncm: improve meta-db accuracy * ncm: inline getlatestkey * fs: improve UnsupportedOperation results * fs: modernize mount utils * ams: misc fixes for merge-errors * fs: improve unsupportedoperation results * git subrepo pull emummc subrepo: subdir: "emummc" merged: "d12dd546" upstream: origin: "https://github.com/m4xw/emuMMC" branch: "develop" commit: "d12dd546" git-subrepo: version: "0.4.1" origin: "???" commit: "???" * util: add boundedmap * ncm: minor style fixes * ncm: don't unmount if mounting fails * lr: bug fixes * ncm: implement ncm.for-initialize + ncm.for-safemode * lr: ncm::ProgramId::Invalid -> ncm::InvalidProgramId * ncm: fix open directory mode on 1.0.0 * ncm: fix fs use, implement more of < 4.0.0 for-initialize/safemode * ncm: implement packagedcontent -> content for building metadb * ncm: fix save data flag management * ncm: address some review suggestions (thanks @leoetlino!) * updater: use fs bindings * fs: implement MountCode * fs: prefer make_unique to operator new * ncm: implement remaining ContentMetaDatabaseBuilder functionality Co-authored-by: Michael Scire <SciresM@gmail.com>
2020-03-08 08:06:23 +00:00
R_SUCCEED_IF(is_valid);
2019-06-21 01:23:40 +00:00
}
access_control = access_control.GetNextEntry();
}
R_THROW(sm::ResultNotAllowed());
2019-06-21 01:23:40 +00:00
}
Result ValidateAccessControl(AccessControlEntry restriction, AccessControlEntry access) {
/* Ensure that every entry in the access control is allowed by the restriction control. */
while (access.IsValid()) {
R_TRY(ValidateAccessControl(restriction, access.GetServiceName(), access.IsHost(), access.IsWildcard()));
access = access.GetNextEntry();
}
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
Result ValidateServiceName(ServiceName service) {
/* Service names must be non-empty. */
R_UNLESS(service.name[0] != 0, sm::ResultInvalidServiceName());
2019-06-21 01:23:40 +00:00
/* Get name length. */
2019-06-21 06:34:59 +00:00
size_t name_len;
for (name_len = 1; name_len < sizeof(service); name_len++) {
2019-06-21 01:23:40 +00:00
if (service.name[name_len] == 0) {
break;
}
}
/* Names must be all-zero after they end. */
while (name_len < sizeof(service)) {
R_UNLESS(service.name[name_len++] == 0, sm::ResultInvalidServiceName());
2019-06-21 01:23:40 +00:00
}
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
bool ShouldDeferForInit(ServiceName service) {
/* Once end has been called, we're done. */
if (g_ended_initial_defers) {
return false;
}
/* This is a mechanism by which certain services will always be deferred until sm:m receives a special command. */
/* This can be extended with more services as needed at a later date. */
for (const auto &service_name : InitiallyDeferredServices) {
if (service == service_name) {
return true;
}
}
return false;
}
ProcessInfo *GetProcessInfo(os::ProcessId process_id) {
/* Find a process info with a matching id. */
for (auto &process_info : g_process_list) {
if (process_info.process_id == process_id) {
return std::addressof(process_info);
}
}
return nullptr;
}
ProcessInfo *GetFreeProcessInfo() {
return GetProcessInfo(os::InvalidProcessId);
}
bool HasProcessInfo(os::ProcessId process_id) {
return GetProcessInfo(process_id) != nullptr;
2019-06-21 01:23:40 +00:00
}
ServiceInfo *GetServiceInfo(ServiceName service_name) {
/* Find a service with a matching name. */
for (auto &service_info : g_service_list) {
if (service_info.name == service_name) {
return std::addressof(service_info);
}
}
return nullptr;
}
ServiceInfo *GetFreeServiceInfo() {
return GetServiceInfo(InvalidServiceName);
}
bool HasServiceInfo(ServiceName service) {
return GetServiceInfo(service) != nullptr;
}
MitmInfo *GetMitmInfo(const ServiceInfo *service_info) {
if (service_info->mitm_index < MitmCountMax) {
return std::addressof(g_mitm_list[service_info->mitm_index]);
} else {
return nullptr;
}
}
MitmInfo *GetFreeMitmInfo() {
/* Find a mitm info without an owner. */
for (auto &mitm_info : g_mitm_list) {
if (!IsValidProcessId(mitm_info.process_id)) {
return std::addressof(mitm_info);
}
}
return nullptr;
}
bool HasMitm(ServiceName service) {
const ServiceInfo *service_info = GetServiceInfo(service);
return service_info != nullptr && GetMitmInfo(service_info) != nullptr;
}
Result AddFutureMitmDeclaration(ServiceName service) {
for (auto &future_mitm : g_future_mitm_list) {
if (future_mitm == InvalidServiceName) {
future_mitm = service;
R_SUCCEED();
}
}
R_THROW(sm::ResultOutOfServices());
}
bool HasFutureMitmDeclaration(ServiceName service) {
for (const auto &future_mitm : g_future_mitm_list){
if (future_mitm == service) {
return true;
}
}
return false;
}
void ClearFutureMitmDeclaration(ServiceName service) {
for (auto &future_mitm : g_future_mitm_list) {
if (future_mitm == service) {
future_mitm = InvalidServiceName;
}
}
/* This might undefer some requests. */
TriggerResume(service);
}
void GetMitmProcessInfo(MitmProcessInfo *out_info, os::ProcessId process_id) {
/* Anything that can request a mitm session must have a process info. */
const auto process_info = GetProcessInfo(process_id);
AMS_ABORT_UNLESS(process_info != nullptr);
/* Write to output. */
out_info->process_id = process_id;
out_info->program_id = process_info->program_id;
out_info->override_status = process_info->override_status;
}
bool IsMitmDisallowed(ncm::ProgramId program_id) {
/* Mitm used on certain programs can prevent the boot process from completing. */
/* TODO: Is there a way to do this that's less hardcoded? Needs design thought. */
return program_id == ncm::SystemProgramId::Loader ||
program_id == ncm::SystemProgramId::Pm ||
program_id == ncm::SystemProgramId::Spl ||
program_id == ncm::SystemProgramId::Boot ||
program_id == ncm::SystemProgramId::Ncm ||
program_id == ncm::AtmosphereProgramId::Mitm ||
program_id == ncm::SystemProgramId::Creport;
}
2021-10-12 07:20:21 +00:00
Result CreatePortImpl(os::NativeHandle *out_server, os::NativeHandle *out_client, size_t max_sessions, bool is_light, sm::ServiceName &name) {
/* Create the port. */
svc::Handle server_port, client_port;
R_TRY(svc::CreatePort(std::addressof(server_port), std::addressof(client_port), max_sessions, is_light, reinterpret_cast<uintptr_t>(name.name)));
/* Set the output handles. */
*out_server = server_port;
*out_client = client_port;
R_SUCCEED();
2021-10-12 07:20:21 +00:00
}
Result ConnectToPortImpl(os::NativeHandle *out, os::NativeHandle port) {
/* Connect to the port. */
svc::Handle session;
R_TRY(svc::ConnectToPort(std::addressof(session), port));
/* Set the output handle. */
*out = session;
R_SUCCEED();
2021-10-12 07:20:21 +00:00
}
Result GetMitmServiceHandleImpl(os::NativeHandle *out, ServiceInfo *service_info, const MitmProcessInfo &client_info) {
/* Get the mitm info. */
MitmInfo *mitm_info = GetMitmInfo(service_info);
AMS_ABORT_UNLESS(mitm_info != nullptr);
2019-06-21 01:23:40 +00:00
/* Send command to query if we should mitm. */
bool should_mitm;
{
/* TODO: Convert mitm internal messaging to use tipc? */
::Service srv { .session = mitm_info->query_h };
R_ABORT_UNLESS(::serviceDispatchInOut(std::addressof(srv), 65000, client_info, should_mitm));
2019-06-21 01:23:40 +00:00
}
/* If we shouldn't mitm, give normal session. */
2021-10-12 07:20:21 +00:00
R_UNLESS(should_mitm, ConnectToPortImpl(out, service_info->port_h));
2019-06-21 01:23:40 +00:00
2019-06-21 06:51:15 +00:00
/* Create both handles. */
{
/* Get the forward handle. */
2021-10-12 07:20:21 +00:00
R_TRY(ConnectToPortImpl(std::addressof(mitm_info->fwd_sess_h), service_info->port_h));
/* Get the mitm handle. */
/* This should be guaranteed to succeed, since we got a forward handle. */
2021-10-12 07:20:21 +00:00
R_ABORT_UNLESS(ConnectToPortImpl(out, mitm_info->port_h));
2019-06-21 06:51:15 +00:00
}
2019-06-21 01:23:40 +00:00
mitm_info->waiting_ack_process_id = client_info.process_id;
mitm_info->waiting_ack = true;
2019-06-21 01:23:40 +00:00
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
Result GetServiceHandleImpl(os::NativeHandle *out, ServiceInfo *service_info, os::ProcessId process_id) {
/* Get the mitm info. */
MitmInfo *mitm_info = GetMitmInfo(service_info);
/* Check if we should return a mitm handle. */
if (mitm_info != nullptr && mitm_info->process_id != process_id) {
/* Get mitm process info, ensure that we're allowed to mitm the given program. */
MitmProcessInfo client_info;
GetMitmProcessInfo(std::addressof(client_info), process_id);
if (!IsMitmDisallowed(client_info.program_id)) {
/* Get a mitm service handle. */
R_RETURN(GetMitmServiceHandleImpl(out, service_info, client_info));
}
2019-06-21 01:23:40 +00:00
}
/* We're not returning a mitm handle, so just return a normal port handle. */
R_RETURN(ConnectToPortImpl(out, service_info->port_h));
2019-06-21 01:23:40 +00:00
}
Result RegisterServiceImpl(os::NativeHandle *out, os::ProcessId process_id, ServiceName service, size_t max_sessions, bool is_light) {
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Don't try to register something already registered. */
R_UNLESS(!HasServiceInfo(service), sm::ResultAlreadyRegistered());
2019-06-21 01:23:40 +00:00
/* Get free service. */
ServiceInfo *free_service = GetFreeServiceInfo();
R_UNLESS(free_service != nullptr, sm::ResultOutOfServices());
2019-06-21 01:23:40 +00:00
/* Create the new service. */
2021-10-12 07:20:21 +00:00
R_TRY(CreatePortImpl(out, std::addressof(free_service->port_h), max_sessions, is_light, free_service->name));
2019-06-21 01:23:40 +00:00
/* Save info. */
free_service->name = service;
free_service->owner_process_id = process_id;
free_service->max_sessions = max_sessions;
free_service->is_light = is_light;
2019-06-21 01:23:40 +00:00
/* This might undefer some requests. */
TriggerResume(service);
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
void UnregisterServiceImpl(ServiceInfo *service_info) {
/* Get the mitm info. */
MitmInfo *mitm_info = GetMitmInfo(service_info);
/* Close all valid handles. */
os::CloseNativeHandle(service_info->port_h);
/* Reset the info's state. */
*service_info = InvalidServiceInfo;
/* Reset the mitm info, if necessary. */
if (mitm_info != nullptr) {
os::CloseNativeHandle(mitm_info->port_h);
os::CloseNativeHandle(mitm_info->query_h);
os::CloseNativeHandle(mitm_info->fwd_sess_h);
*mitm_info = InvalidMitmInfo;
}
}
}
/* Client disconnection callback. */
void OnClientDisconnected(os::ProcessId process_id) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
/* Ensure that the process id is valid. */
if (process_id == os::InvalidProcessId) {
return;
}
/* Unregister all services a client hosts, on attached-client-close. */
for (auto &service_info : g_service_list) {
if (service_info.name != InvalidServiceName && service_info.owner_process_id == process_id) {
UnregisterServiceImpl(std::addressof(service_info));
}
}
2019-06-21 01:23:40 +00:00
}
/* Process management. */
Result RegisterProcess(os::ProcessId process_id, ncm::ProgramId program_id, cfg::OverrideStatus override_status, const void *acid_sac, size_t acid_sac_size, const void *aci_sac, size_t aci_sac_size) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Check that access control will fit in the ServiceInfo. */
R_UNLESS(aci_sac_size <= AccessControlSizeMax, sm::ResultTooLargeAccessControl());
2019-06-21 01:23:40 +00:00
/* Get free process. */
ProcessInfo *proc = GetFreeProcessInfo();
R_UNLESS(proc != nullptr, sm::ResultOutOfProcesses());
2019-06-21 01:23:40 +00:00
/* Validate restrictions. */
R_UNLESS(aci_sac_size != 0, sm::ResultNotAllowed());
R_TRY(ValidateAccessControl(AccessControlEntry(acid_sac, acid_sac_size), AccessControlEntry(aci_sac, aci_sac_size)));
2019-06-21 01:23:40 +00:00
/* Save info. */
proc->process_id = process_id;
proc->program_id = program_id;
proc->override_status = override_status;
proc->access_control_size = aci_sac_size;
std::memcpy(proc->access_control, aci_sac, proc->access_control_size);
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
Result UnregisterProcess(os::ProcessId process_id) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Find the process. */
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
2019-06-21 01:23:40 +00:00
/* Free the process. */
*proc = InvalidProcessInfo;
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
/* Service management. */
Result HasService(bool *out, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
/* Validate service name. */
R_TRY(ValidateServiceName(service));
2019-06-21 01:23:40 +00:00
*out = HasServiceInfo(service);
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
2019-07-03 05:21:47 +00:00
Result WaitService(ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
/* Check that we have the service. */
2019-07-03 05:21:47 +00:00
bool has_service = false;
R_TRY(impl::HasService(std::addressof(has_service), service));
2019-07-03 05:21:47 +00:00
/* If we don't, we want to wait until the service is registered. */
R_UNLESS(has_service, tipc::ResultRequestDeferred());
R_SUCCEED();
2019-07-03 05:21:47 +00:00
}
Result GetServiceHandle(os::NativeHandle *out, os::ProcessId process_id, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
2019-06-21 06:51:15 +00:00
/* Check that the process is registered and allowed to get the service. */
if (!IsInitialProcess(process_id)) {
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
2019-06-21 01:23:40 +00:00
R_TRY(ValidateAccessControl(AccessControlEntry(proc->access_control, proc->access_control_size), service, false, false));
}
/* Get service info/mitm info. */
2019-06-21 01:23:40 +00:00
ServiceInfo *service_info = GetServiceInfo(service);
MitmInfo *mitm_info = service_info != nullptr ? GetMitmInfo(service_info) : nullptr;
/* Check to see if we need to defer until later. */
R_UNLESS(service_info != nullptr, tipc::ResultRequestDeferred());
R_UNLESS(!ShouldDeferForInit(service), tipc::ResultRequestDeferred());
R_UNLESS(!HasFutureMitmDeclaration(service), tipc::ResultRequestDeferred());
R_UNLESS((mitm_info == nullptr || !mitm_info->waiting_ack), tipc::ResultRequestDeferred());
2019-06-21 01:23:40 +00:00
/* Get a handle from the service info. */
R_TRY_CATCH(GetServiceHandleImpl(out, service_info, process_id)) {
R_CONVERT(svc::ResultOutOfSessions, sm::ResultOutOfSessions())
2019-06-21 01:23:40 +00:00
} R_END_TRY_CATCH;
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
Result RegisterService(os::NativeHandle *out, os::ProcessId process_id, ServiceName service, size_t max_sessions, bool is_light) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Check that the process is registered and allowed to register the service. */
if (!IsInitialProcess(process_id)) {
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
2019-06-21 01:23:40 +00:00
R_TRY(ValidateAccessControl(AccessControlEntry(proc->access_control, proc->access_control_size), service, true, false));
}
/* Check that the service isn't already registered. */
R_UNLESS(!HasServiceInfo(service), sm::ResultAlreadyRegistered());
R_RETURN(RegisterServiceImpl(out, process_id, service, max_sessions, is_light));
2019-06-21 01:23:40 +00:00
}
Result RegisterServiceForSelf(os::NativeHandle *out, ServiceName service, size_t max_sessions) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
R_RETURN(RegisterServiceImpl(out, os::GetCurrentProcessId(), service, max_sessions, false));
2019-06-21 01:23:40 +00:00
}
Result UnregisterService(os::ProcessId process_id, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Check that the process is registered. */
if (!IsInitialProcess(process_id)) {
R_UNLESS(HasProcessInfo(process_id), sm::ResultInvalidClient());
2019-06-21 01:23:40 +00:00
}
/* Ensure that the service is actually registered. */
ServiceInfo *service_info = GetServiceInfo(service);
R_UNLESS(service_info != nullptr, sm::ResultNotRegistered());
2019-06-21 01:23:40 +00:00
/* Check if we have permission to do this. */
R_UNLESS(service_info->owner_process_id == process_id, sm::ResultNotAllowed());
2019-06-21 01:23:40 +00:00
/* Unregister the service. */
UnregisterServiceImpl(service_info);
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
/* Mitm extensions. */
Result HasMitm(bool *out, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Get whether we have a mitm. */
*out = HasMitm(service);
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
2019-07-03 05:21:47 +00:00
Result WaitMitm(ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
/* Check that we have the mitm. */
2019-07-03 05:21:47 +00:00
bool has_mitm = false;
R_TRY(impl::HasMitm(std::addressof(has_mitm), service));
2019-07-03 05:21:47 +00:00
/* If we don't, we want to wait until the mitm is installed. */
R_UNLESS(has_mitm, tipc::ResultRequestDeferred());
R_SUCCEED();
2019-07-03 05:21:47 +00:00
}
Result InstallMitm(os::NativeHandle *out, os::NativeHandle *out_query, os::ProcessId process_id, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Check that the process is registered and allowed to register the service. */
if (!IsInitialProcess(process_id)) {
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
2019-06-21 01:23:40 +00:00
R_TRY(ValidateAccessControl(AccessControlEntry(proc->access_control, proc->access_control_size), service, true, false));
}
/* Validate that the service exists. */
ServiceInfo *service_info = GetServiceInfo(service);
/* If it doesn't exist, defer until it does. */
R_UNLESS(service_info != nullptr, tipc::ResultRequestDeferred());
2019-06-21 01:23:40 +00:00
/* Validate that the service isn't already being mitm'd. */
R_UNLESS(GetMitmInfo(service_info) == nullptr, sm::ResultAlreadyRegistered());
/* Validate that we can create a new mitm. */
MitmInfo *mitm_info = GetFreeMitmInfo();
R_UNLESS(mitm_info != nullptr, sm::ResultOutOfServices());
2019-06-21 01:23:40 +00:00
/* If we don't have a future mitm declaration, add one. */
/* Client will clear this when ready to process. */
const bool has_existing_future_declaration = HasFutureMitmDeclaration(service);
if (!has_existing_future_declaration) {
R_TRY(AddFutureMitmDeclaration(service));
}
/* If we fail past this point, clean up the future mitm declaration we just added. */
ON_RESULT_FAILURE { if (!has_existing_future_declaration) { ClearFutureMitmDeclaration(service); } };
2019-06-21 01:23:40 +00:00
/* Create mitm handles. */
2019-06-21 06:51:15 +00:00
{
/* Get the port handles. */
os::NativeHandle hnd, port_hnd;
2021-10-12 07:20:21 +00:00
R_TRY(CreatePortImpl(std::addressof(hnd), std::addressof(port_hnd), service_info->max_sessions, service_info->is_light, service_info->name));
/* Ensure that we clean up the port handles, if something goes wrong creating the query sessions. */
ON_RESULT_FAILURE { os::CloseNativeHandle(hnd); os::CloseNativeHandle(port_hnd); };
/* Create the session for our query service. */
os::NativeHandle qry_hnd, mitm_qry_hnd;
R_TRY(svc::CreateSession(std::addressof(qry_hnd), std::addressof(mitm_qry_hnd), false, 0));
/* Setup the mitm info. */
mitm_info->process_id = process_id;
mitm_info->port_h = port_hnd;
mitm_info->query_h = mitm_qry_hnd;
/* Setup the service info. */
service_info->mitm_index = mitm_info - g_mitm_list.data();
2019-06-21 06:51:15 +00:00
/* Copy to output. */
*out = hnd;
*out_query = qry_hnd;
/* This might undefer some requests. */
TriggerResume(service);
2019-06-21 06:51:15 +00:00
}
2019-06-21 01:23:40 +00:00
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
Result UninstallMitm(os::ProcessId process_id, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Check that the process is registered. */
if (!IsInitialProcess(process_id)) {
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
2019-06-21 01:23:40 +00:00
}
/* Validate that the service exists. */
ServiceInfo *service_info = GetServiceInfo(service);
R_UNLESS(service_info != nullptr, sm::ResultNotRegistered());
2019-06-21 01:23:40 +00:00
/* Validate that the service is mitm'd. */
MitmInfo *mitm_info = GetMitmInfo(service_info);
R_UNLESS(mitm_info != nullptr, sm::ResultNotRegistered());
/* Validate that the client process_id is the mitm process. */
R_UNLESS(mitm_info->process_id == process_id, sm::ResultNotAllowed());
2019-06-21 01:23:40 +00:00
/* Uninstall the mitm. */
{
/* Close mitm handles. */
os::CloseNativeHandle(mitm_info->port_h);
os::CloseNativeHandle(mitm_info->query_h);
os::CloseNativeHandle(mitm_info->fwd_sess_h);
/* Reset mitm members. */
*mitm_info = InvalidMitmInfo;
/* Reset service info. */
service_info->mitm_index = MitmCountMax;
}
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
Result DeclareFutureMitm(os::ProcessId process_id, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Check that the process is registered and allowed to register the service. */
if (!IsInitialProcess(process_id)) {
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
R_TRY(ValidateAccessControl(AccessControlEntry(proc->access_control, proc->access_control_size), service, true, false));
}
/* Check that mitm hasn't already been registered or declared. */
R_UNLESS(!HasMitm(service), sm::ResultAlreadyRegistered());
R_UNLESS(!HasFutureMitmDeclaration(service), sm::ResultAlreadyRegistered());
/* Try to forward declare it. */
R_TRY(AddFutureMitmDeclaration(service));
R_SUCCEED();
}
Result ClearFutureMitm(os::ProcessId process_id, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Check that the process is registered and allowed to register the service. */
if (!IsInitialProcess(process_id)) {
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
R_TRY(ValidateAccessControl(AccessControlEntry(proc->access_control, proc->access_control_size), service, true, false));
}
/* Validate that the service exists. */
ServiceInfo *service_info = GetServiceInfo(service);
R_UNLESS(service_info != nullptr, sm::ResultNotRegistered());
/* Check that we have a mitm or a future declaration. */
if (MitmInfo *mitm_info = GetMitmInfo(service_info); mitm_info != nullptr) {
/* Validate that the client process_id is the mitm process. */
R_UNLESS(mitm_info->process_id == process_id, sm::ResultNotAllowed());
} else {
R_UNLESS(HasFutureMitmDeclaration(service), sm::ResultNotRegistered());
}
/* Clear the forward declaration. */
ClearFutureMitmDeclaration(service);
R_SUCCEED();
}
Result AcknowledgeMitmSession(MitmProcessInfo *out_info, os::NativeHandle *out_hnd, os::ProcessId process_id, ServiceName service) {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
2019-06-21 01:23:40 +00:00
/* Validate service name. */
R_TRY(ValidateServiceName(service));
/* Check that the process is registered. */
if (!IsInitialProcess(process_id)) {
ProcessInfo *proc = GetProcessInfo(process_id);
R_UNLESS(proc != nullptr, sm::ResultInvalidClient());
2019-06-21 01:23:40 +00:00
}
/* Validate that the service exists. */
ServiceInfo *service_info = GetServiceInfo(service);
R_UNLESS(service_info != nullptr, sm::ResultNotRegistered());
2019-06-21 01:23:40 +00:00
/* Get the mitm info. */
MitmInfo *mitm_info = GetMitmInfo(service_info);
R_UNLESS(mitm_info != nullptr, sm::ResultNotRegistered());
/* Validate that the client process_id is the mitm process, and that an acknowledgement is waiting. */
R_UNLESS(mitm_info->process_id == process_id, sm::ResultNotAllowed());
R_UNLESS(mitm_info->waiting_ack, sm::ResultNotAllowed());
2019-06-21 01:23:40 +00:00
2019-06-21 06:34:59 +00:00
/* Acknowledge. */
{
/* Copy the mitm info to output. */
GetMitmProcessInfo(out_info, mitm_info->waiting_ack_process_id);
2019-06-21 01:23:40 +00:00
/* Set the output handle. */
*out_hnd = mitm_info->fwd_sess_h;
mitm_info->fwd_sess_h = os::InvalidNativeHandle;
2019-06-21 01:23:40 +00:00
/* Clear acknowledgement-related fields. */
mitm_info->waiting_ack = false;
mitm_info->waiting_ack_process_id = os::InvalidProcessId;
2019-06-21 01:23:40 +00:00
}
/* Undefer requests to the session. */
TriggerResume(service);
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
/* Deferral extension (works around FS bug). */
Result EndInitialDefers() {
/* Acquire exclusive access to global state. */
std::scoped_lock lk(g_mutex);
/* Note that we have ended the initial deferral period. */
const bool had_ended_defers = g_ended_initial_defers;
2019-06-21 01:23:40 +00:00
g_ended_initial_defers = true;
/* Something about deferral state has changed, so we should refresh our hos version. */
hos::InitializeVersionInternal(!had_ended_defers);
/* This might undefer some requests. */
for (const auto &service_name : InitiallyDeferredServices) {
TriggerResume(service_name);
}
R_SUCCEED();
2019-06-21 01:23:40 +00:00
}
2019-06-21 01:32:00 +00:00
}