mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2024-11-08 21:21:48 +00:00
524 lines
23 KiB
C++
524 lines
23 KiB
C++
/*
|
|
* Copyright (c) 2018-2020 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 "sysupdater_service.hpp"
|
|
#include "sysupdater_async_impl.hpp"
|
|
#include "sysupdater_fs_utils.hpp"
|
|
|
|
namespace ams::mitm::sysupdater {
|
|
|
|
namespace {
|
|
|
|
/* ExFat NCAs prior to 2.0.0 do not actually include the exfat driver, and don't boot. */
|
|
constexpr inline u32 MinimumVersionForExFatDriver = 65536;
|
|
|
|
bool IsExFatDriverSupported(const ncm::ContentMetaInfo &info) {
|
|
return info.version >= MinimumVersionForExFatDriver && ((info.attributes & ncm::ContentMetaAttribute_IncludesExFatDriver) != 0);
|
|
}
|
|
|
|
template<typename F>
|
|
Result ForEachFileInDirectory(const char *root_path, F f) {
|
|
/* Open the directory. */
|
|
fs::DirectoryHandle dir;
|
|
R_TRY(fs::OpenDirectory(std::addressof(dir), root_path, fs::OpenDirectoryMode_File));
|
|
ON_SCOPE_EXIT { fs::CloseDirectory(dir); };
|
|
|
|
while (true) {
|
|
/* Read the current entry. */
|
|
s64 count;
|
|
fs::DirectoryEntry entry;
|
|
R_TRY(fs::ReadDirectory(std::addressof(count), std::addressof(entry), dir, 1));
|
|
if (count == 0) {
|
|
break;
|
|
}
|
|
|
|
/* Invoke our handler on the entry. */
|
|
bool done;
|
|
R_TRY(f(std::addressof(done), entry));
|
|
R_SUCCEED_IF(done);
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result ConvertToFsCommonPath(char *dst, size_t dst_size, const char *package_root_path, const char *entry_path) {
|
|
char package_path[ams::fs::EntryNameLengthMax];
|
|
|
|
const size_t path_len = util::SNPrintf(package_path, sizeof(package_path), "%s%s", package_root_path, entry_path);
|
|
AMS_ABORT_UNLESS(path_len < ams::fs::EntryNameLengthMax);
|
|
|
|
return ams::fs::ConvertToFsCommonPath(dst, dst_size, package_path);
|
|
}
|
|
|
|
Result LoadContentMeta(ncm::AutoBuffer *out, const char *package_root_path, const fs::DirectoryEntry &entry) {
|
|
AMS_ABORT_UNLESS(PathView(entry.name).HasSuffix(".cnmt.nca"));
|
|
|
|
char path[ams::fs::EntryNameLengthMax];
|
|
R_TRY(ConvertToFsCommonPath(path, sizeof(path), package_root_path, entry.name));
|
|
|
|
return ncm::ReadContentMetaPath(out, path);
|
|
}
|
|
|
|
Result ReadContentMetaPath(ncm::AutoBuffer *out, const char *package_root, const ncm::ContentInfo &content_info) {
|
|
/* Get the .cnmt.nca path for the info. */
|
|
char cnmt_nca_name[ncm::ContentIdStringLength + 10];
|
|
ncm::GetStringFromContentId(cnmt_nca_name, sizeof(cnmt_nca_name), content_info.GetId());
|
|
std::memcpy(cnmt_nca_name + ncm::ContentIdStringLength, ".cnmt.nca", std::strlen(".cnmt.nca"));
|
|
cnmt_nca_name[sizeof(cnmt_nca_name) - 1] = '\x00';
|
|
|
|
/* Create a new path. */
|
|
ncm::Path content_path;
|
|
R_TRY(ConvertToFsCommonPath(content_path.str, sizeof(content_path.str), package_root, cnmt_nca_name));
|
|
|
|
/* Read the content meta path. */
|
|
return ncm::ReadContentMetaPath(out, content_path.str);
|
|
}
|
|
|
|
Result GetSystemUpdateUpdateContentInfoFromPackage(ncm::ContentInfo *out, const char *package_root) {
|
|
bool found_system_update = false;
|
|
|
|
/* Iterate over all files to find the system update meta. */
|
|
R_TRY(ForEachFileInDirectory(package_root, [&](bool *done, const fs::DirectoryEntry &entry) -> Result {
|
|
/* Don't early terminate by default. */
|
|
*done = false;
|
|
|
|
/* We have nothing to list if we're not looking at a meta. */
|
|
R_SUCCEED_IF(!PathView(entry.name).HasSuffix(".cnmt.nca"));
|
|
|
|
/* Read the content meta path, and build. */
|
|
ncm::AutoBuffer package_meta;
|
|
R_TRY(LoadContentMeta(std::addressof(package_meta), package_root, entry));
|
|
|
|
/* Create a reader. */
|
|
const auto reader = ncm::PackagedContentMetaReader(package_meta.Get(), package_meta.GetSize());
|
|
|
|
/* If we find a system update, we're potentially done. */
|
|
if (reader.GetHeader()->type == ncm::ContentMetaType::SystemUpdate) {
|
|
/* Try to parse a content id from the name. */
|
|
auto content_id = ncm::GetContentIdFromString(entry.name, sizeof(entry.name));
|
|
R_UNLESS(content_id, ncm::ResultInvalidPackageFormat());
|
|
|
|
/* We're done. */
|
|
*done = true;
|
|
found_system_update = true;
|
|
|
|
*out = ncm::ContentInfo::Make(*content_id, entry.file_size, ncm::ContentType::Meta);
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}));
|
|
|
|
/* If we didn't find anything, error. */
|
|
R_UNLESS(found_system_update, ncm::ResultSystemUpdateNotFoundInPackage());
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result ValidateSystemUpdate(Result *out_result, Result *out_exfat_result, UpdateValidationInfo *out_info, const ncm::PackagedContentMetaReader &update_reader, const char *package_root) {
|
|
/* Clear output. */
|
|
*out_result = ResultSuccess();
|
|
*out_exfat_result = ResultSuccess();
|
|
|
|
/* We want to track all content the update requires. */
|
|
const size_t num_content_metas = update_reader.GetContentMetaCount();
|
|
bool content_meta_valid[num_content_metas] = {};
|
|
|
|
/* Allocate a buffer to use for validation. */
|
|
size_t data_buffer_size = 1_MB;
|
|
void *data_buffer;
|
|
do {
|
|
data_buffer = std::malloc(data_buffer_size);
|
|
if (data_buffer != nullptr) {
|
|
break;
|
|
}
|
|
|
|
data_buffer_size /= 2;
|
|
} while (data_buffer_size >= 16_KB);
|
|
R_UNLESS(data_buffer != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
ON_SCOPE_EXIT { std::free(data_buffer); };
|
|
|
|
/* Declare helper for result validation. */
|
|
auto ValidateResult = [&] ALWAYS_INLINE_LAMBDA (Result result) -> Result {
|
|
*out_result = result;
|
|
return result;
|
|
};
|
|
|
|
/* Iterate over all files to find all content metas. */
|
|
R_TRY(ForEachFileInDirectory(package_root, [&](bool *done, const fs::DirectoryEntry &entry) -> Result {
|
|
/* Clear output. */
|
|
*out_info = {};
|
|
|
|
/* Don't early terminate by default. */
|
|
*done = false;
|
|
|
|
/* We have nothing to list if we're not looking at a meta. */
|
|
R_SUCCEED_IF(!PathView(entry.name).HasSuffix(".cnmt.nca"));
|
|
|
|
/* Read the content meta path, and build. */
|
|
ncm::AutoBuffer package_meta;
|
|
R_TRY(LoadContentMeta(std::addressof(package_meta), package_root, entry));
|
|
|
|
/* Create a reader. */
|
|
const auto reader = ncm::PackagedContentMetaReader(package_meta.Get(), package_meta.GetSize());
|
|
|
|
/* Get the key for the reader. */
|
|
const auto key = reader.GetKey();
|
|
|
|
/* Check if we need to validate this content. */
|
|
bool need_validate = false;
|
|
size_t validation_index = 0;
|
|
for (size_t i = 0; i < num_content_metas; ++i) {
|
|
if (update_reader.GetContentMetaInfo(i)->ToKey() == key) {
|
|
need_validate = true;
|
|
validation_index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* If we don't need to validate, continue. */
|
|
R_SUCCEED_IF(!need_validate);
|
|
|
|
/* We're validating. */
|
|
out_info->invalid_key = key;
|
|
|
|
/* Validate all contents. */
|
|
for (size_t i = 0; i < reader.GetContentCount(); ++i) {
|
|
const auto *content_info = reader.GetContentInfo(i);
|
|
const auto &content_id = content_info->GetId();
|
|
const s64 content_size = content_info->info.GetSize();
|
|
out_info->invalid_content_id = content_id;
|
|
|
|
/* Get the content id string. */
|
|
auto content_id_str = ncm::GetContentIdString(content_id);
|
|
|
|
/* Open the file. */
|
|
fs::FileHandle file;
|
|
{
|
|
char path[fs::EntryNameLengthMax];
|
|
util::SNPrintf(path, sizeof(path), "%s%s%s", package_root, content_id_str.data, content_info->GetType() == ncm::ContentType::Meta ? ".cnmt.nca" : ".nca");
|
|
if (R_FAILED(ValidateResult(fs::OpenFile(std::addressof(file), path, ams::fs::OpenMode_Read)))) {
|
|
*done = true;
|
|
return ResultSuccess();
|
|
}
|
|
}
|
|
ON_SCOPE_EXIT { fs::CloseFile(file); };
|
|
|
|
/* Validate the file size is correct. */
|
|
s64 file_size;
|
|
if (R_FAILED(ValidateResult(fs::GetFileSize(std::addressof(file_size), file)))) {
|
|
*done = true;
|
|
return ResultSuccess();
|
|
}
|
|
if (file_size != content_size) {
|
|
*out_result = ncm::ResultInvalidContentHash();
|
|
*done = true;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
/* Read and hash the file in chunks. */
|
|
crypto::Sha256Generator sha;
|
|
sha.Initialize();
|
|
|
|
s64 ofs = 0;
|
|
while (ofs < content_size) {
|
|
const size_t cur_size = std::min(static_cast<size_t>(content_size - ofs), data_buffer_size);
|
|
if (R_FAILED(ValidateResult(fs::ReadFile(file, ofs, data_buffer, cur_size)))) {
|
|
*done = true;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
sha.Update(data_buffer, cur_size);
|
|
|
|
ofs += cur_size;
|
|
}
|
|
|
|
/* Get the hash. */
|
|
ncm::Digest calc_digest;
|
|
sha.GetHash(std::addressof(calc_digest), sizeof(calc_digest));
|
|
|
|
/* Validate the hash. */
|
|
if (std::memcmp(std::addressof(calc_digest), std::addressof(content_info->digest), sizeof(ncm::Digest)) != 0) {
|
|
*out_result = ncm::ResultInvalidContentHash();
|
|
*done = true;
|
|
return ResultSuccess();
|
|
}
|
|
}
|
|
|
|
/* Mark the relevant content as validated. */
|
|
content_meta_valid[validation_index] = true;
|
|
*out_info = {};
|
|
|
|
return ResultSuccess();
|
|
}));
|
|
|
|
/* If we're otherwise going to succeed, ensure that every content was found. */
|
|
if (R_SUCCEEDED(*out_result)) {
|
|
for (size_t i = 0; i < num_content_metas; ++i) {
|
|
if (!content_meta_valid[i]) {
|
|
const ncm::ContentMetaInfo *info = update_reader.GetContentMetaInfo(i);
|
|
|
|
*out_info = { .invalid_key = info->ToKey(), };
|
|
|
|
if (IsExFatDriverSupported(*info)) {
|
|
*out_exfat_result = fs::ResultPathNotFound();
|
|
/* Continue, in case there's a non-exFAT failure result. */
|
|
} else {
|
|
*out_result = fs::ResultPathNotFound();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result FormatUserPackagePath(ncm::Path *out, const ncm::Path &user_path) {
|
|
/* Ensure that the user path is valid. */
|
|
R_UNLESS(user_path.str[0] == '/', fs::ResultInvalidPath());
|
|
|
|
/* Print as @Sdcard:<user_path>/ */
|
|
util::SNPrintf(out->str, sizeof(out->str), "%s:%s/", ams::fs::impl::SdCardFileSystemMountName, user_path.str);
|
|
|
|
/* Normalize, if the user provided an ending / */
|
|
const size_t len = std::strlen(out->str);
|
|
if (out->str[len - 1] == '/' && out->str[len - 2] == '/') {
|
|
out->str[len - 1] = '\x00';
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
const char *GetFirmwareVariationSettingName(settings::system::PlatformRegion region) {
|
|
switch (region) {
|
|
case settings::system::PlatformRegion_Global: return "firmware_variation";
|
|
case settings::system::PlatformRegion_China: return "t_firmware_variation";
|
|
AMS_UNREACHABLE_DEFAULT_CASE();
|
|
}
|
|
}
|
|
|
|
ncm::FirmwareVariationId GetFirmwareVariationId() {
|
|
/* Get the firmware variation setting name. */
|
|
const char * const setting_name = GetFirmwareVariationSettingName(settings::system::GetPlatformRegion());
|
|
|
|
/* Retrieve the firmware variation id. */
|
|
ncm::FirmwareVariationId id = {};
|
|
settings::fwdbg::GetSettingsItemValue(std::addressof(id.value), sizeof(u8), "ns.systemupdate", setting_name);
|
|
|
|
return id;
|
|
}
|
|
|
|
}
|
|
|
|
Result SystemUpdateService::GetUpdateInformation(sf::Out<UpdateInformation> out, const ncm::Path &path) {
|
|
/* Adjust the path. */
|
|
ncm::Path package_root;
|
|
R_TRY(FormatUserPackagePath(std::addressof(package_root), path));
|
|
|
|
/* Create a new update information. */
|
|
UpdateInformation update_info = {};
|
|
|
|
/* Parse the update. */
|
|
{
|
|
/* Get the content info for the system update. */
|
|
ncm::ContentInfo content_info;
|
|
R_TRY(GetSystemUpdateUpdateContentInfoFromPackage(std::addressof(content_info), package_root.str));
|
|
|
|
/* Read the content meta. */
|
|
ncm::AutoBuffer content_meta_buffer;
|
|
R_TRY(ReadContentMetaPath(std::addressof(content_meta_buffer), package_root.str, content_info));
|
|
|
|
/* Create a reader. */
|
|
const auto reader = ncm::PackagedContentMetaReader(content_meta_buffer.Get(), content_meta_buffer.GetSize());
|
|
|
|
/* Get the version from the header. */
|
|
update_info.version = reader.GetHeader()->version;
|
|
|
|
/* Iterate over infos to find the system update info. */
|
|
for (size_t i = 0; i < reader.GetContentMetaCount(); ++i) {
|
|
const auto &meta_info = *reader.GetContentMetaInfo(i);
|
|
|
|
switch (meta_info.type) {
|
|
case ncm::ContentMetaType::BootImagePackage:
|
|
/* Detect exFAT support. */
|
|
update_info.exfat_supported |= IsExFatDriverSupported(meta_info);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Default to no firmware variations. */
|
|
update_info.firmware_variation_count = 0;
|
|
|
|
/* Parse firmware variations if relevant. */
|
|
if (reader.GetExtendedDataSize() != 0) {
|
|
/* Get the actual firmware variation count. */
|
|
ncm::SystemUpdateMetaExtendedDataReader extended_data_reader(reader.GetExtendedData(), reader.GetExtendedDataSize());
|
|
update_info.firmware_variation_count = extended_data_reader.GetFirmwareVariationCount();
|
|
|
|
/* NOTE: Update this if Nintendo ever actually releases an update with this many variations? */
|
|
R_UNLESS(update_info.firmware_variation_count <= FirmwareVariationCountMax, ncm::ResultInvalidFirmwareVariation());
|
|
|
|
for (size_t i = 0; i < update_info.firmware_variation_count; ++i) {
|
|
update_info.firmware_variation_ids[i] = *extended_data_reader.GetFirmwareVariationId(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Set the parsed update info. */
|
|
out.SetValue(update_info);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result SystemUpdateService::ValidateUpdate(sf::Out<Result> out_validate_result, sf::Out<Result> out_validate_exfat_result, sf::Out<UpdateValidationInfo> out_validate_info, const ncm::Path &path) {
|
|
/* Adjust the path. */
|
|
ncm::Path package_root;
|
|
R_TRY(FormatUserPackagePath(std::addressof(package_root), path));
|
|
|
|
/* Parse the update. */
|
|
{
|
|
/* Get the content info for the system update. */
|
|
ncm::ContentInfo content_info;
|
|
R_TRY(GetSystemUpdateUpdateContentInfoFromPackage(std::addressof(content_info), package_root.str));
|
|
|
|
/* Read the content meta. */
|
|
ncm::AutoBuffer content_meta_buffer;
|
|
R_TRY(ReadContentMetaPath(std::addressof(content_meta_buffer), package_root.str, content_info));
|
|
|
|
/* Create a reader. */
|
|
const auto reader = ncm::PackagedContentMetaReader(content_meta_buffer.Get(), content_meta_buffer.GetSize());
|
|
|
|
/* Validate the update. */
|
|
R_TRY(ValidateSystemUpdate(out_validate_result.GetPointer(), out_validate_exfat_result.GetPointer(), out_validate_info.GetPointer(), reader, package_root.str));
|
|
}
|
|
|
|
return ResultSuccess();
|
|
};
|
|
|
|
Result SystemUpdateService::SetupUpdate(sf::CopyHandle transfer_memory, u64 transfer_memory_size, const ncm::Path &path, bool exfat) {
|
|
return this->SetupUpdateImpl(transfer_memory.GetValue(), transfer_memory_size, path, exfat, GetFirmwareVariationId());
|
|
}
|
|
|
|
Result SystemUpdateService::SetupUpdateWithVariation(sf::CopyHandle transfer_memory, u64 transfer_memory_size, const ncm::Path &path, bool exfat, ncm::FirmwareVariationId firmware_variation_id) {
|
|
return this->SetupUpdateImpl(transfer_memory.GetValue(), transfer_memory_size, path, exfat, firmware_variation_id);
|
|
}
|
|
|
|
Result SystemUpdateService::RequestPrepareUpdate(sf::OutCopyHandle out_event_handle, sf::Out<std::shared_ptr<ns::impl::IAsyncResult>> out_async) {
|
|
/* Ensure the update is setup but not prepared. */
|
|
R_UNLESS(this->setup_update, ns::ResultCardUpdateNotSetup());
|
|
R_UNLESS(!this->requested_update, ns::ResultPrepareCardUpdateAlreadyRequested());
|
|
|
|
/* Create the async result. */
|
|
auto async_result = sf::MakeShared<ns::impl::IAsyncResult, AsyncPrepareSdCardUpdateImpl>(std::addressof(*this->update_task));
|
|
R_UNLESS(async_result != nullptr, ns::ResultOutOfMaxRunningTask());
|
|
|
|
/* Run the task. */
|
|
R_TRY(async_result->GetImpl().Run());
|
|
|
|
/* We prepared the task! */
|
|
this->requested_update = true;
|
|
out_event_handle.SetValue(async_result->GetImpl().GetEvent().GetReadableHandle());
|
|
out_async.SetValue(std::move(async_result));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result SystemUpdateService::GetPrepareUpdateProgress(sf::Out<SystemUpdateProgress> out) {
|
|
/* Ensure the update is setup. */
|
|
R_UNLESS(this->setup_update, ns::ResultCardUpdateNotSetup());
|
|
|
|
/* Get the progress. */
|
|
auto install_progress = this->update_task->GetProgress();
|
|
out.SetValue({ .current_size = install_progress.installed_size, .total_size = install_progress.total_size });
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result SystemUpdateService::HasPreparedUpdate(sf::Out<bool> out) {
|
|
/* Ensure the update is setup. */
|
|
R_UNLESS(this->setup_update, ns::ResultCardUpdateNotSetup());
|
|
|
|
out.SetValue(this->update_task->GetProgress().state == ncm::InstallProgressState::Downloaded);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result SystemUpdateService::ApplyPreparedUpdate() {
|
|
/* Ensure the update is setup. */
|
|
R_UNLESS(this->setup_update, ns::ResultCardUpdateNotSetup());
|
|
|
|
/* Ensure the update is prepared. */
|
|
R_UNLESS(this->update_task->GetProgress().state == ncm::InstallProgressState::Downloaded, ns::ResultCardUpdateNotPrepared());
|
|
|
|
/* Apply the task. */
|
|
R_TRY(this->apply_manager.ApplyPackageTask(std::addressof(*this->update_task)));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result SystemUpdateService::SetupUpdateImpl(os::ManagedHandle transfer_memory, u64 transfer_memory_size, const ncm::Path &path, bool exfat, ncm::FirmwareVariationId firmware_variation_id) {
|
|
/* Ensure we don't already have an update set up. */
|
|
R_UNLESS(!this->setup_update, ns::ResultCardUpdateAlreadySetup());
|
|
|
|
/* Destroy any existing update tasks. */
|
|
nim::SystemUpdateTaskId id;
|
|
auto count = nim::ListSystemUpdateTask(std::addressof(id), 1);
|
|
if (count > 0) {
|
|
R_TRY(nim::DestroySystemUpdateTask(id));
|
|
}
|
|
|
|
/* Initialize the update task. */
|
|
R_TRY(InitializeUpdateTask(transfer_memory, transfer_memory_size, path, exfat, firmware_variation_id));
|
|
|
|
/* The update is now set up. */
|
|
this->setup_update = true;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result SystemUpdateService::InitializeUpdateTask(os::ManagedHandle &transfer_memory_handle, u64 transfer_memory_size, const ncm::Path &path, bool exfat, ncm::FirmwareVariationId firmware_variation_id) {
|
|
/* Map the transfer memory. */
|
|
const size_t tmem_buffer_size = static_cast<size_t>(transfer_memory_size);
|
|
this->update_transfer_memory.emplace(tmem_buffer_size, transfer_memory_handle.Get(), true);
|
|
|
|
void *tmem_buffer;
|
|
R_TRY(this->update_transfer_memory->Map(std::addressof(tmem_buffer), os::MemoryPermission_None));
|
|
auto tmem_guard = SCOPE_GUARD {
|
|
this->update_transfer_memory->Unmap();
|
|
this->update_transfer_memory = std::nullopt;
|
|
};
|
|
|
|
/* Now that the memory is mapped, the input handle is managed and can be released. */
|
|
transfer_memory_handle.Detach();
|
|
|
|
/* Adjust the package root. */
|
|
ncm::Path package_root;
|
|
R_TRY(FormatUserPackagePath(std::addressof(package_root), path));
|
|
|
|
/* Ensure that we can create an update context. */
|
|
R_TRY(fs::EnsureDirectoryRecursively("@Sdcard:/atmosphere/update/"));
|
|
const char *context_path = "@Sdcard:/atmosphere/update/cup.ctx";
|
|
|
|
/* Create and initialize the update task. */
|
|
this->update_task.emplace();
|
|
R_TRY(this->update_task->Initialize(package_root.str, context_path, tmem_buffer, tmem_buffer_size, exfat, firmware_variation_id));
|
|
|
|
/* We successfully setup the update. */
|
|
tmem_guard.Cancel();
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
}
|