mirror of
https://github.com/rvtr/ctr_Repair.git
synced 2025-10-31 13:51:08 -04:00
dc298ff550
をマージ git-svn-id: file:///Volumes/Transfer/gigaleak_20231201/2020-05-23%20-%20ctr.7z%20+%20svn_v1.068.zip/ctr/svn/ctr_Repair@326 385bec56-5757-e545-9c3a-d8741f4650f1
575 lines
17 KiB
C++
575 lines
17 KiB
C++
/*---------------------------------------------------------------------------*
|
|
Project: Horizon
|
|
File: Exporter.cpp
|
|
|
|
Copyright 2009 Nintendo. All rights reserved.
|
|
|
|
These coded instructions, statements, and computer programs contain
|
|
proprietary information of Nintendo of America Inc. and/or Nintendo
|
|
Company Ltd., and are protected by Federal copyright law. They may
|
|
not be disclosed to third parties or copied or duplicated in any form,
|
|
in whole or in part, without the prior written consent of Nintendo.
|
|
|
|
$Rev$
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
#include <vector>
|
|
#include <cstdlib>
|
|
#include <cwchar>
|
|
#include <string>
|
|
#include <cstdlib>
|
|
#include <nn/fs/CTR/fs_ArchiveTypesForSystem.h>
|
|
#include <nn/fs/CTR/MPCore/fs_FileSystemBasePrivate.h>
|
|
#include <nn/cfg/CTR/cfg_Api.h>
|
|
#include <nn/cfg/CTR/cfg_ApiNor.h> // cfg:norの初期化に必要
|
|
#include <nn/cfg/CTR/cfg_NtrSettings.h>
|
|
#include <nn/ps/CTR/ps_API.h>
|
|
#include <nn/drivers/aes/CTR/ARM946ES/driverAes_Types.h>
|
|
#include <nn/crypto/crypto_SwAesCtrContext.h>
|
|
#include <nn/mcu.h>
|
|
#include <nn/pl/CTR/pl_PlayHistoryApi.h>
|
|
#include <nn/pl/CTR/pl_PlayHistoryApiSysmenu.h>
|
|
|
|
#include "Exporter.h"
|
|
#include "CommonLogger.h"
|
|
#include "SDMountManager.h"
|
|
#include "ConsoleBackup.h"
|
|
#include "HeapManager.h"
|
|
#include "SdReaderWriter.h"
|
|
#include "FileName.h"
|
|
#include "FileTransfer.h"
|
|
#include "common_Types.h"
|
|
#include "Aes_define.h"
|
|
#include "PlayHistoryManager.h"
|
|
#include "VersionDetect.h"
|
|
|
|
namespace ConsoleBackup
|
|
{
|
|
|
|
namespace
|
|
{
|
|
|
|
common::SdReaderWriter s_SdWriter;
|
|
common::NtrNorData s_NtrNorData;
|
|
common::CfgCountryLanguage s_CountryLanguage;
|
|
|
|
::std::string s_SysSaveRoot;
|
|
|
|
const size_t EXPORT_THREAD_STACK_SIZE = 0x4000;
|
|
nn::os::Thread s_ExportThread;
|
|
nn::os::StackBuffer<EXPORT_THREAD_STACK_SIZE> s_ExportThreadStack;
|
|
|
|
wchar_t s_RootName[256];
|
|
|
|
}
|
|
|
|
void DeleteTrash(std::wstring currentDirectory)
|
|
{
|
|
// TODO: リードオンリーのファイルが消去できない
|
|
|
|
COMMON_LOGGER("Delete Trash.\n");
|
|
|
|
nn::fs::FileInputStream fis;
|
|
nn::fs::Directory dir;
|
|
nn::Result result;
|
|
std::vector<nn::fs::DirectoryEntry> entryList; //カレントディレクトリのエントリ一覧を格納
|
|
std::vector<nn::fs::DirectoryEntry>::iterator entryIndex;
|
|
|
|
common::SdMountManager::Mount();
|
|
|
|
result = dir.TryInitialize(currentDirectory.c_str());
|
|
|
|
if (result.IsSuccess())
|
|
{
|
|
nn::fs::DirectoryEntry entry;
|
|
s32 numEntry;
|
|
for (;;)
|
|
{
|
|
result = dir.TryRead(&numEntry, &entry, 1);
|
|
if (result.IsFailure())
|
|
{
|
|
dir.Finalize();
|
|
}
|
|
if (numEntry == 0)
|
|
{
|
|
// ルートディレクトリを閉じる
|
|
dir.Finalize();
|
|
|
|
// ルートディレクトリの子を開く
|
|
for (entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++)
|
|
{
|
|
// ディレクトリなら削除する
|
|
if (entryIndex->attributes.isDirectory)
|
|
{
|
|
NN_LOG("Try Delete %ls%ls/\n", currentDirectory.c_str(), entryIndex->entryName);
|
|
result = nn::fs::TryDeleteDirectoryRecursively((currentDirectory + ::std::wstring(
|
|
entryIndex->entryName)).c_str());
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
}
|
|
// ファイルならログとAP設定以外は削除する
|
|
else
|
|
{
|
|
if (std::wcscmp(entryIndex->entryName, common::AP_SETTING_FILENAME) != 0 && std::wcscmp(
|
|
entryIndex->entryName, common::LOG_FILENAME) != 0)
|
|
{
|
|
NN_LOG("Try Delete %ls%ls\n", currentDirectory.c_str(), entryIndex->entryName);
|
|
result = nn::fs::TryDeleteFile(
|
|
(currentDirectory + ::std::wstring(entryIndex->entryName)).c_str());
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 削除完了
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// vectorに保存する
|
|
entryList.push_back(entry);
|
|
if (entry.attributes.isDirectory)
|
|
{
|
|
NN_LOG("%ls%ls/\n", currentDirectory.c_str(), entry.entryName);
|
|
}
|
|
else
|
|
{
|
|
NN_LOG("%ls%ls\n", currentDirectory.c_str(), entry.entryName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NN_LOG("failed initialize directory\n");
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
dir.Finalize();
|
|
}
|
|
|
|
common::SdMountManager::Unmount();
|
|
}
|
|
|
|
void WriteRegionData()
|
|
{
|
|
COMMON_LOGGER("Export Region Data.\n");
|
|
|
|
nn::cfg::CTR::CfgRegionCode region;
|
|
region = nn::cfg::CTR::GetRegion();
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::REGION_DATA_PATHNAME, ®ion, sizeof(nn::cfg::CTR::CfgRegionCode));
|
|
}
|
|
|
|
void WriteCountryLanguageData()
|
|
{
|
|
COMMON_LOGGER("Export Country and Language Data.\n");
|
|
|
|
nn::Result result;
|
|
|
|
nn::cfg::nor::CTR::Initialize();
|
|
|
|
// 国設定
|
|
s_CountryLanguage.country = nn::cfg::CTR::GetCountry();
|
|
if (s_CountryLanguage.country != nn::cfg::CTR::CFG_COUNTRY_UNKNOWN)
|
|
{
|
|
// 言語設定
|
|
s_CountryLanguage.language = nn::cfg::CTR::GetLanguage();
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::COUNTRY_SETTING_PATHNAME, &s_CountryLanguage, sizeof(s_CountryLanguage));
|
|
}
|
|
}
|
|
|
|
void WriteNorData()
|
|
{
|
|
COMMON_LOGGER("Export NOR Data.\n");
|
|
|
|
nn::Result result;
|
|
|
|
nn::cfg::nor::CTR::Initialize();
|
|
|
|
NN_LOG("Get NTR User Setting\n");
|
|
|
|
// NTR設定
|
|
result = nn::cfg::nor::CTR::GetNtrSetting(&s_NtrNorData.ntrConfig.ncd, &s_NtrNorData.ntrConfig.ncd_ex);
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
// TWL WiFi設定
|
|
result = nn::cfg::nor::CTR::ReadTwlWifiSetting(0, s_NtrNorData.TwlWiFiSetting, common::TWL_WIFI_SETTING_SIZE);
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
// NTR WiFi設定
|
|
result = nn::cfg::nor::CTR::ReadNtrWifiSetting(0, s_NtrNorData.NtrWiFiSetting, common::NTR_WIFI_SETTING_SIZE);
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::NOR_PATHNAME, &s_NtrNorData, sizeof(common::NtrNorData));
|
|
}
|
|
|
|
void WriteSerialNumber()
|
|
{
|
|
COMMON_LOGGER("Export Serial Number.\n");
|
|
|
|
u8* serial;
|
|
size_t size;
|
|
GetSerialNumber(&serial, &size);
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::SERIAL_PATHNAME, serial, size);
|
|
}
|
|
|
|
void WriteDeviceId()
|
|
{
|
|
COMMON_LOGGER("Export Device ID.\n");
|
|
|
|
bit32 deviceId = GetDeviceId();
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::DEVICE_ID_PATHNAME, &deviceId, sizeof(deviceId));
|
|
}
|
|
|
|
void WriteIvs()
|
|
{
|
|
COMMON_LOGGER("Export IVS.\n");
|
|
|
|
void* ivs;
|
|
size_t size;
|
|
GetIvs(&ivs, &size);
|
|
|
|
void* enc;
|
|
nn::Result result;
|
|
enc = common::HeapManager::GetHeap()->Allocate(size);
|
|
if(enc != NULL)
|
|
{
|
|
// AES暗号化する
|
|
nn::crypto::Initialize();
|
|
|
|
nn::crypto::SwAesCtrContext swAesCtrContest;
|
|
|
|
swAesCtrContest.Initialize(common::iv, common::key, sizeof(common::key));
|
|
swAesCtrContest.Encrypt(enc, ivs, size);
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::IVS_PATHNAME, enc, size);
|
|
|
|
common::HeapManager::GetHeap()->Free(enc);
|
|
}
|
|
}
|
|
|
|
// IVSからセーブデータディレクトリ名を生成する
|
|
void GetSaveDataDirectoryRoot()
|
|
{
|
|
nn::Result result;
|
|
using namespace nn::dbg;
|
|
|
|
const size_t SEED_SIZE = 16;
|
|
bit8 hash[nn::crypto::Sha256Context::HASH_SIZE];
|
|
const size_t SYS_SAVE_ROOT_LENGTH = 16;
|
|
char rootHash[SYS_SAVE_ROOT_LENGTH];
|
|
char rootStr[SYS_SAVE_ROOT_LENGTH * 2 + 1];
|
|
|
|
void* addr;
|
|
size_t size;
|
|
GetIvs(&addr, &size);
|
|
|
|
// 最後の16バイトのハッシュを使う
|
|
nn::crypto::CalculateSha256(hash, &reinterpret_cast<bit8*> (addr)[size - SEED_SIZE], SEED_SIZE);
|
|
|
|
for (u8 i = 0; i < SEED_SIZE / 4; i++)
|
|
{
|
|
for (u8 j = 0; j < SEED_SIZE / 4; j++)
|
|
{
|
|
rootHash[i * 4 + j] = hash[i * 4 + 3 - j];
|
|
}
|
|
}
|
|
|
|
// 得られたハッシュから文字列を生成
|
|
for (s32 k = 0; k < SEED_SIZE; k++)
|
|
{
|
|
for (s32 i = 6; i < 8; ++i)
|
|
{
|
|
bit32 n = (rootHash[k] >> ((7 - i) * 4)) & 0xf;
|
|
NN_TASSERT_(n < 16);
|
|
rootStr[i - 6 + k * 2] = static_cast<char> (n < 10 ? '0' + n : 'a' + (n - 10));
|
|
}
|
|
}
|
|
rootStr[SYS_SAVE_ROOT_LENGTH * 2] = '\0';
|
|
|
|
// セーブデータディレクトリ名を保存する
|
|
s_SysSaveRoot = ::std::string(rootStr);
|
|
|
|
NN_LOG("%s\n", s_SysSaveRoot.c_str());
|
|
}
|
|
|
|
void CreateTwlDirectory(enum common::TWL_PATH_INDEX path)
|
|
{
|
|
NN_ASSERT(path < common::TWL_PATHNAME_MAX);
|
|
|
|
s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) +
|
|
std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str());
|
|
}
|
|
|
|
void WriteTwlData(enum common::TWL_PATH_INDEX path)
|
|
{
|
|
NN_ASSERT(path < common::TWL_PATHNAME_MAX);
|
|
|
|
nn::Result result;
|
|
|
|
result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[path], common::TWL_FS_ARCHIVE_KIND[path]);
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
result = common::SdMountManager::Mount();
|
|
|
|
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize();
|
|
NN_LOG("AllocatableSize = %d\n", bufSize);
|
|
|
|
u32 fileNum = 0;
|
|
u32 fileSize = 0;
|
|
common::CalculateFileNum(::std::wstring(common::NAND_TWL_ROOT_PATHNAME_WITH_SLASH_TABLE[path]), fileNum, fileSize);
|
|
|
|
nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
|
|
|
|
NN_LOG("File Number = %d\n", fileNum);
|
|
NN_LOG("File Size = %d\n", fileSize);
|
|
// 進捗表示用
|
|
common::InitializeTransferProgress(fileSize);
|
|
|
|
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE);
|
|
if (buf != NULL)
|
|
{
|
|
wchar_t archiveName[256];
|
|
::std::mbstowcs(archiveName, common::TWL_ARCHIVE_NAME_TABLE[path], std::strlen(common::TWL_ARCHIVE_NAME_TABLE[path]) + 1);
|
|
std::wstring archiveString(archiveName);
|
|
common::CopyDirectory(
|
|
(archiveString + ::std::wstring(L"/")).c_str(),
|
|
(common::SDMC_ROOT_DIRECTORY_PATH + ::std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str(),
|
|
buf, bufSize, true);
|
|
|
|
common::HeapManager::GetHeap()->Free(buf);
|
|
}
|
|
|
|
common::SdMountManager::Unmount();
|
|
nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[path]);
|
|
|
|
}
|
|
|
|
void WriteTwlPhotoData()
|
|
{
|
|
COMMON_LOGGER("Export Twl Photo Data.\n");
|
|
CreateTwlDirectory(common::TWL_PHOTO);
|
|
WriteTwlData(common::TWL_PHOTO);
|
|
}
|
|
|
|
void WriteTwlSoundData()
|
|
{
|
|
COMMON_LOGGER("Export Twl Sound Data.\n");
|
|
CreateTwlDirectory(common::TWL_SOUND);
|
|
WriteTwlData(common::TWL_SOUND);
|
|
}
|
|
|
|
void ExportTwlPhotoData()
|
|
{
|
|
s_ExportThread.Start(WriteTwlPhotoData, s_ExportThreadStack);
|
|
}
|
|
|
|
void ExportTwlSoundData()
|
|
{
|
|
// 不要なデータを削除する
|
|
DeleteTrash(common::SDMC_ROOT_DIRECTORY_PATH);
|
|
|
|
s_ExportThread.Start(WriteTwlSoundData, s_ExportThreadStack);
|
|
}
|
|
|
|
|
|
void WriteMcuRtcData()
|
|
{
|
|
COMMON_LOGGER("Export RTC Data.\n");
|
|
nn::Result result;
|
|
nn::Handle handle = GetMcuHandle();
|
|
|
|
if(handle.IsValid())
|
|
{
|
|
nn::mcu::CTR::HwCheck mcu(handle);
|
|
|
|
nn::mcu::CTR::RtcData rtc;
|
|
result = mcu.GetRtcAll(&rtc);
|
|
NN_LOG("RTC = 20%02d/%02d/%02d %02d:%02d:%02d\n", rtc.m_Year, rtc.m_Month, rtc.m_Day, rtc.m_Hour, rtc.m_Minute, rtc.m_Second);
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::MCU_RTC_PATHNAME, &rtc, sizeof(rtc));
|
|
}
|
|
else
|
|
{
|
|
NN_LOG("invalid handle\n");
|
|
}
|
|
}
|
|
|
|
void ExportThreadFunc()
|
|
{
|
|
nn::Result result;
|
|
|
|
result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND);
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
result = common::SdMountManager::Mount();
|
|
|
|
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize();
|
|
NN_LOG("AllocatableSize = %d\n", bufSize);
|
|
|
|
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE);
|
|
if (buf != NULL)
|
|
{
|
|
|
|
common::CopyDirectory(
|
|
(::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str(),
|
|
(common::SDMC_ROOT_DIRECTORY_PATH + ::std::wstring(common::SD_SAVEDATA_ROOT_NAME) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str(),
|
|
buf, bufSize, true);
|
|
|
|
common::HeapManager::GetHeap()->Free(buf);
|
|
}
|
|
|
|
common::SdMountManager::Unmount();
|
|
nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
|
|
|
|
NN_LOG("Export Thread Finalize\n");
|
|
}
|
|
|
|
nn::Result WriteSaveData()
|
|
{
|
|
// NANDからSDカードに書き出し
|
|
nn::Result result;
|
|
|
|
result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND);
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
u32 fileNum = 0;
|
|
u32 fileSize = 0;
|
|
common::CalculateFileNum(::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH), fileNum, fileSize);
|
|
|
|
nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
|
|
|
|
NN_LOG("File Number = %d\n", fileNum);
|
|
NN_LOG("File Size = %d\n", fileSize);
|
|
// 進捗表示用
|
|
common::InitializeTransferProgress(fileSize);
|
|
|
|
::std::mbstowcs(s_RootName, s_SysSaveRoot.c_str(), s_SysSaveRoot.size() + 1);
|
|
|
|
NN_LOG("%ls\n", (::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str());
|
|
|
|
// セーブデータディレクトリ以下のデータをSDカードにコピー
|
|
// コピー用ディレクトリ作成
|
|
s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(
|
|
common::SD_SAVEDATA_ROOT_NAME)).c_str());
|
|
s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(
|
|
common::SD_SAVEDATA_ROOT_NAME) + ::std::wstring(s_RootName) + ::std::wstring(L"/")).c_str());
|
|
|
|
COMMON_LOGGER("Export NAND Data Start...\n");
|
|
|
|
// SDにコピーするためのスレッドの作成
|
|
s_ExportThread.Start(ExportThreadFunc, s_ExportThreadStack);
|
|
|
|
return result;
|
|
}
|
|
|
|
void FinalizeExportThread()
|
|
{
|
|
s_ExportThread.Join();
|
|
s_ExportThread.Finalize();
|
|
}
|
|
|
|
void WriteVersionData()
|
|
{
|
|
COMMON_LOGGER("Export Version Data.\n");
|
|
|
|
common::VerDef versionData;
|
|
GetVersionData(&versionData);
|
|
|
|
s_SdWriter.WriteBufWithCmac(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef));
|
|
}
|
|
|
|
void WritePlayHistory()
|
|
{
|
|
common::PlayHistoryManager historyManager;
|
|
|
|
COMMON_LOGGER("Export PlayHistory\n");
|
|
historyManager.Export();
|
|
}
|
|
|
|
void DeleteNimSaveData()
|
|
{
|
|
nn::Result result;
|
|
::std::wstring nimSaveDataPath =
|
|
::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) +
|
|
::std::wstring(common::SD_SAVEDATA_ROOT_NAME) +
|
|
::std::wstring(s_RootName) +
|
|
::std::wstring(L"/") +
|
|
std::wstring(common::NIM_SAVEDATA_DIRECTORY_NAME);
|
|
|
|
common::SdMountManager::Mount();
|
|
|
|
NN_LOG("%ls\n", nimSaveDataPath.c_str());
|
|
result = nn::fs::TryDeleteDirectoryRecursively(nimSaveDataPath.c_str());
|
|
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
|
|
|
|
common::SdMountManager::Unmount();
|
|
}
|
|
|
|
void AddShutDownPtmEvent()
|
|
{
|
|
nn::pl::CTR::NotifyPlayEvent(nn::pl::CTR::EVENTTYPE_TERMINATE, nn::CTR::INVALID_PROGRAM_ID,
|
|
nn::fnd::DateTime::GetNow());
|
|
}
|
|
|
|
void ExportData()
|
|
{
|
|
static bool init = true;
|
|
|
|
if (init)
|
|
{
|
|
// リージョンデータをSDに書き込む
|
|
WriteRegionData();
|
|
|
|
// 国データと言語データをSDに書き込む
|
|
WriteCountryLanguageData();
|
|
|
|
// NORデータをSDカードに書き込む
|
|
WriteNorData();
|
|
|
|
// シリアルナンバーをSDカードに書き込む
|
|
WriteSerialNumber();
|
|
|
|
// デバイスIDをSDカードに書き込む
|
|
WriteDeviceId();
|
|
|
|
// 完全性検証SEEDをSDカードに書き込む
|
|
WriteIvs();
|
|
|
|
// IVSからセーブデータディレクトリ名を計算
|
|
GetSaveDataDirectoryRoot();
|
|
|
|
// プレイ履歴をSDに書き出す
|
|
//WritePlayHistory();
|
|
|
|
// 電源断の履歴をptmに追加する
|
|
AddShutDownPtmEvent();
|
|
|
|
// RTCをSDに書き出す
|
|
WriteMcuRtcData();
|
|
|
|
// バージョン情報をSDに書き出す
|
|
WriteVersionData();
|
|
|
|
// NANDのセーブデータをSDに書き出す
|
|
WriteSaveData();
|
|
|
|
init = false;
|
|
}
|
|
}
|
|
|
|
u32 GetProgress()
|
|
{
|
|
return common::GetProgress();
|
|
}
|
|
|
|
bool IsExportFinished()
|
|
{
|
|
return s_ExportThread.IsValid() && !s_ExportThread.IsAlive();
|
|
}
|
|
|
|
}
|