mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2025-10-31 11:15:51 +01:00
273 lines
12 KiB
C++
273 lines
12 KiB
C++
/*
|
|
* Copyright (c) Atmosphère-NX
|
|
*
|
|
* 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>
|
|
#include "setsys_mitm_service.hpp"
|
|
#include "settings_sd_kvs.hpp"
|
|
#include "setsys_shim.h"
|
|
|
|
namespace ams::mitm::settings {
|
|
|
|
using namespace ams::settings;
|
|
|
|
namespace {
|
|
|
|
constexpr const char ExternalBluetoothDatabasePath[] = "@Sdcard:/atmosphere/bluetooth_devices.db";
|
|
|
|
constinit os::SdkMutex g_firmware_version_lock;
|
|
constinit bool g_cached_firmware_version;
|
|
constinit settings::FirmwareVersion g_firmware_version;
|
|
constinit settings::FirmwareVersion g_ams_firmware_version;
|
|
|
|
void CacheFirmwareVersion() {
|
|
if (AMS_LIKELY(g_cached_firmware_version)) {
|
|
return;
|
|
}
|
|
|
|
std::scoped_lock lk(g_firmware_version_lock);
|
|
|
|
if (AMS_UNLIKELY(g_cached_firmware_version)) {
|
|
return;
|
|
}
|
|
|
|
/* Mount firmware version data archive. */
|
|
{
|
|
R_ABORT_UNLESS(ams::fs::MountSystemData("sysver", ncm::SystemDataId::SystemVersion));
|
|
ON_SCOPE_EXIT { ams::fs::Unmount("sysver"); };
|
|
|
|
/* Firmware version file must exist. */
|
|
ams::fs::FileHandle file;
|
|
R_ABORT_UNLESS(ams::fs::OpenFile(std::addressof(file), "sysver:/file", fs::OpenMode_Read));
|
|
ON_SCOPE_EXIT { ams::fs::CloseFile(file); };
|
|
|
|
/* Must be possible to read firmware version from file. */
|
|
R_ABORT_UNLESS(ams::fs::ReadFile(file, 0, std::addressof(g_firmware_version), sizeof(g_firmware_version)));
|
|
|
|
g_ams_firmware_version = g_firmware_version;
|
|
}
|
|
|
|
/* Modify the atmosphere firmware version to display a custom version string. */
|
|
{
|
|
const auto api_info = exosphere::GetApiInfo();
|
|
const char emummc_char = emummc::IsActive() ? 'E' : 'S';
|
|
|
|
/* NOTE: We have carefully accounted for the size of the string we print. */
|
|
/* No truncation occurs assuming two-digits for all version number components. */
|
|
char display_version[sizeof(g_ams_firmware_version.display_version)];
|
|
|
|
util::SNPrintf(display_version, sizeof(display_version), "%s|AMS %u.%u.%u|%c", g_ams_firmware_version.display_version, api_info.GetMajorVersion(), api_info.GetMinorVersion(), api_info.GetMicroVersion(), emummc_char);
|
|
|
|
std::memcpy(g_ams_firmware_version.display_version, display_version, sizeof(display_version));
|
|
}
|
|
|
|
g_cached_firmware_version = true;
|
|
}
|
|
|
|
Result GetFirmwareVersionImpl(settings::FirmwareVersion *out, const sm::MitmProcessInfo &client_info) {
|
|
/* Ensure that we have the firmware version cached. */
|
|
CacheFirmwareVersion();
|
|
|
|
/* We want to give a special firmware version to the home menu title, and nothing else. */
|
|
/* This means qlaunch + maintenance menu, and nothing else. */
|
|
if (client_info.program_id == ncm::SystemAppletId::Qlaunch || client_info.program_id == ncm::SystemAppletId::MaintenanceMenu) {
|
|
*out = g_ams_firmware_version;
|
|
} else {
|
|
*out = g_firmware_version;
|
|
}
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
bool IsExternalBluetoothDatabaseEnabled() {
|
|
u8 en = 0;
|
|
settings::fwdbg::GetSettingsItemValue(std::addressof(en), sizeof(en), "atmosphere", "enable_external_bluetooth_db");
|
|
return en;
|
|
}
|
|
|
|
bool HasExternalBluetoothDatabase() {
|
|
bool file_exists;
|
|
R_ABORT_UNLESS(fs::HasFile(std::addressof(file_exists), ExternalBluetoothDatabasePath));
|
|
return file_exists;
|
|
}
|
|
|
|
Result ReadExternalBluetoothDatabase(s32 *entries_read, settings::BluetoothDevicesSettings *db, size_t db_max_size) {
|
|
/* Open the external database file. */
|
|
fs::FileHandle file;
|
|
R_TRY(fs::OpenFile(std::addressof(file), ExternalBluetoothDatabasePath, fs::OpenMode_Read));
|
|
ON_SCOPE_EXIT { fs::CloseFile(file); };
|
|
|
|
/* Read the number of database entries stored in external database. */
|
|
u64 total_entries;
|
|
R_TRY(fs::ReadFile(file, 0, std::addressof(total_entries), sizeof(total_entries)));
|
|
|
|
u64 db_offset = sizeof(total_entries);
|
|
if (total_entries > db_max_size) {
|
|
/* Pairings are stored from least to most recent. Add offset to skip the older entries that won't fit. */
|
|
db_offset += (total_entries - db_max_size) * sizeof(settings::BluetoothDevicesSettings);
|
|
|
|
/* Cap number of database entries read to size of database on this firmware. */
|
|
total_entries = db_max_size;
|
|
}
|
|
|
|
/* Read database entries. */
|
|
R_TRY(fs::ReadFile(file, db_offset, db, total_entries * sizeof(settings::BluetoothDevicesSettings)));
|
|
|
|
/* Convert entries to the old format if running on a firmware below 13.0.0. */
|
|
if (hos::GetVersion() < hos::Version_13_0_0) {
|
|
for (size_t i = 0; i < total_entries; ++i) {
|
|
/* Copy the newer name field to the older one. */
|
|
util::TSNPrintf(db[i].name, sizeof(db[i].name), "%s", db[i].name2);
|
|
|
|
/* Clear the newer name field. */
|
|
std::memset(db[i].name2, 0, sizeof(db[i].name2));
|
|
}
|
|
}
|
|
|
|
/* Set the output. */
|
|
*entries_read = static_cast<s32>(total_entries);
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result StoreExternalBluetoothDatabase(const settings::BluetoothDevicesSettings *db, u64 total_entries) {
|
|
/* Open the external database file. */
|
|
fs::FileHandle file;
|
|
R_TRY(fs::OpenFile(std::addressof(file), ExternalBluetoothDatabasePath, fs::OpenMode_Write));
|
|
ON_SCOPE_EXIT { fs::CloseFile(file); };
|
|
|
|
/* Ensure the file is the appropriate size for the number of entries. */
|
|
R_TRY(fs::SetFileSize(file, sizeof(total_entries) + total_entries * sizeof(settings::BluetoothDevicesSettings)));
|
|
|
|
/* Write the number of database entries. */
|
|
R_TRY(fs::WriteFile(file, 0, std::addressof(total_entries), sizeof(total_entries), fs::WriteOption::None));
|
|
|
|
/* Write the database entries. */
|
|
u64 db_offset = sizeof(total_entries);
|
|
if (hos::GetVersion() < hos::Version_13_0_0) {
|
|
/* Convert entries to the new format if running on a firmware below 13.0.0. */
|
|
for (size_t i = 0; i < total_entries; ++i) {
|
|
/* Make a copy of the current database entry. */
|
|
settings::BluetoothDevicesSettings tmp = db[i];
|
|
|
|
/* Copy the older name field to the newer one. */
|
|
util::TSNPrintf(tmp.name2, sizeof(tmp.name2), "%s", tmp.name);
|
|
|
|
/* Clear the original name field. */
|
|
std::memset(tmp.name, 0, sizeof(tmp.name));
|
|
|
|
/* Write the converted database entry. */
|
|
R_TRY(fs::WriteFile(file, db_offset, std::addressof(tmp), sizeof(settings::BluetoothDevicesSettings), fs::WriteOption::None));
|
|
|
|
/* Advance to the next database entry. */
|
|
db_offset += sizeof(settings::BluetoothDevicesSettings);
|
|
}
|
|
|
|
/* Flush the data we've written. */
|
|
R_TRY(fs::FlushFile(file));
|
|
} else {
|
|
/* We can just write the database to the file. */
|
|
R_TRY(fs::WriteFile(file, db_offset, db, total_entries * sizeof(settings::BluetoothDevicesSettings), fs::WriteOption::Flush));
|
|
}
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
}
|
|
|
|
Result SetSysMitmService::GetFirmwareVersion(sf::Out<settings::FirmwareVersion> out) {
|
|
R_TRY(GetFirmwareVersionImpl(out.GetPointer(), m_client_info));
|
|
|
|
/* GetFirmwareVersion sanitizes the revision fields. */
|
|
out.GetPointer()->revision_major = 0;
|
|
out.GetPointer()->revision_minor = 0;
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result SetSysMitmService::GetFirmwareVersion2(sf::Out<settings::FirmwareVersion> out) {
|
|
R_RETURN(GetFirmwareVersionImpl(out.GetPointer(), m_client_info));
|
|
}
|
|
|
|
Result SetSysMitmService::SetBluetoothDevicesSettings(const sf::InMapAliasArray<settings::BluetoothDevicesSettings> &settings) {
|
|
/* We only want to perform additional logic when the external database setting is enabled. */
|
|
R_UNLESS(IsExternalBluetoothDatabaseEnabled(), sm::mitm::ResultShouldForwardToSession());
|
|
|
|
/* Create the external database if it doesn't exist. */
|
|
if (!HasExternalBluetoothDatabase()) {
|
|
R_TRY(fs::CreateFile(ExternalBluetoothDatabasePath, 0));
|
|
}
|
|
|
|
/* Backup the local database to the sd card. */
|
|
R_TRY(StoreExternalBluetoothDatabase(settings.GetPointer(), settings.GetSize()));
|
|
|
|
/* Ensure that the updated database is stored to the system save as usual. */
|
|
static_assert(sizeof(settings::BluetoothDevicesSettings) == sizeof(::SetSysBluetoothDevicesSettings));
|
|
R_TRY(setsysSetBluetoothDevicesSettingsFwd(m_forward_service.get(), reinterpret_cast<const ::SetSysBluetoothDevicesSettings *>(settings.GetPointer()), settings.GetSize()));
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result SetSysMitmService::GetBluetoothDevicesSettings(sf::Out<s32> out_count, const sf::OutMapAliasArray<settings::BluetoothDevicesSettings> &out) {
|
|
/* We only want to perform additional logic when the external database setting is enabled. */
|
|
R_UNLESS(IsExternalBluetoothDatabaseEnabled(), sm::mitm::ResultShouldForwardToSession());
|
|
|
|
if (!HasExternalBluetoothDatabase()) {
|
|
/* Fetch the local database from the system save. */
|
|
static_assert(sizeof(settings::BluetoothDevicesSettings) == sizeof(::SetSysBluetoothDevicesSettings));
|
|
R_TRY(setsysGetBluetoothDevicesSettingsFwd(m_forward_service.get(), out_count.GetPointer(), reinterpret_cast<::SetSysBluetoothDevicesSettings *>(out.GetPointer()), out.GetSize()));
|
|
|
|
/* Create the external database file. */
|
|
R_TRY(fs::CreateFile(ExternalBluetoothDatabasePath, 0));
|
|
|
|
/* Backup the local database to the sd card. */
|
|
R_TRY(StoreExternalBluetoothDatabase(out.GetPointer(), out_count.GetValue()));
|
|
} else {
|
|
/* Read the external database from the sd card. */
|
|
R_TRY(ReadExternalBluetoothDatabase(out_count.GetPointer(), out.GetPointer(), out.GetSize()));
|
|
}
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result SetSysMitmService::GetSettingsItemValueSize(sf::Out<u64> out_size, const settings::SettingsName &name, const settings::SettingsItemKey &key) {
|
|
R_TRY_CATCH(settings::fwdbg::GetSdCardKeyValueStoreSettingsItemValueSize(out_size.GetPointer(), name.value, key.value)) {
|
|
R_CATCH_RETHROW(sf::impl::ResultRequestContextChanged)
|
|
R_CONVERT_ALL(sm::mitm::ResultShouldForwardToSession());
|
|
} R_END_TRY_CATCH;
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result SetSysMitmService::GetSettingsItemValue(sf::Out<u64> out_size, const sf::OutBuffer &out, const settings::SettingsName &name, const settings::SettingsItemKey &key) {
|
|
R_TRY_CATCH(settings::fwdbg::GetSdCardKeyValueStoreSettingsItemValue(out_size.GetPointer(), out.GetPointer(), out.GetSize(), name.value, key.value)) {
|
|
R_CATCH_RETHROW(sf::impl::ResultRequestContextChanged)
|
|
R_CONVERT_ALL(sm::mitm::ResultShouldForwardToSession());
|
|
} R_END_TRY_CATCH;
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result SetSysMitmService::GetDebugModeFlag(sf::Out<bool> out) {
|
|
/* If we're not processing for am, just return the real flag value. */
|
|
R_UNLESS(m_client_info.program_id == ncm::SystemProgramId::Am, sm::mitm::ResultShouldForwardToSession());
|
|
|
|
/* Retrieve the user configuration. */
|
|
u8 en = 0;
|
|
settings::fwdbg::GetSettingsItemValue(std::addressof(en), sizeof(en), "atmosphere", "enable_am_debug_mode");
|
|
|
|
out.SetValue(en != 0);
|
|
R_SUCCEED();
|
|
}
|
|
|
|
}
|