rvtr/ctr_Repair
1
Fork 0
mirror of https://github.com/rvtr/ctr_Repair.git synced 2025-10-31 13:51:08 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

FSのTry系APIのハンドリング見直し

Browse Source 
吸出しスレッドのResultをチェックするように
HeapManagerの挙動変更。コンストラクタでAllocateしてデストラクタでFreeするように。
PlayHistoryManagerの削除

git-svn-id: file:///Volumes/Transfer/gigaleak_20231201/2020-05-23%20-%20ctr.7z%20+%20svn_v1.068.zip/ctr/svn/ctr_Repair@358 385bec56-5757-e545-9c3a-d8741f4650f1
This commit is contained in:
N2614 2011-07-06 07:20:39 +00:00
parent 8ec38b53a9
commit eeca247d7e
27 changed files with 681 additions and 884 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
trunk/ConsoleDataMigration/sources/ConsoleBackup/ConsoleBackup.cpp
View File

@ -47,7 +47,6 @@
#include "CommonLogger.h" #include "CommonLogger.h"
#include "SDMountManager.h" #include "SDMountManager.h"
#include "HeapManager.h" #include "HeapManager.h"
#include "PlayHistoryManager.h"
#include "common_Types.h" #include "common_Types.h"
#include "VersionDetect.h" #include "VersionDetect.h"
#include "Util.h" #include "Util.h"
@ -111,10 +110,11 @@ extern "C" void nnMain(void)
nn::am::InitializeForSystemMenu(); nn::am::InitializeForSystemMenu();
// ヒープの確保 // ヒープの確保
common::HeapManager::GetHeap()->Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR); common::InitializeHeap();
// RenderSystem の準備 // RenderSystem の準備
uptr heapForGx = reinterpret_cast<uptr>(common::HeapManager::GetHeap()->Allocate(s_GxHeapSize)); common::HeapManager gxHeapManager(s_GxHeapSize);
uptr heapForGx = reinterpret_cast<uptr>(gxHeapManager.GetAddr());
demo::RenderSystemDrawing renderSystem; demo::RenderSystemDrawing renderSystem;
renderSystem.Initialize(heapForGx, s_GxHeapSize); renderSystem.Initialize(heapForGx, s_GxHeapSize);

58
trunk/ConsoleDataMigration/sources/ConsoleBackup/Controller.cpp
View File

@ -171,7 +171,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (IsExportThreadFinished()) if (IsExportThreadFinished())
{ {
FinalizeExportThread(); FinalizeExportThread();
s_BackupState = EXPORT_TWL_SOUND; if(IsExportSucceeded())
{
s_BackupState = EXPORT_TWL_SOUND;
}
else
{
s_BackupState = FAIL;
}
} }
} }
break; break;
@ -191,7 +199,14 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (IsExportThreadFinished()) if (IsExportThreadFinished())
{ {
FinalizeExportThread(); FinalizeExportThread();
s_BackupState = EXPORT_TWL_PHOTO; if(IsExportSucceeded())
{
s_BackupState = EXPORT_TWL_PHOTO;
}
else
{
s_BackupState = FAIL;
}
} }
} }
break; break;
@ -211,7 +226,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (IsExportThreadFinished()) if (IsExportThreadFinished())
{ {
FinalizeExportThread(); FinalizeExportThread();
s_BackupState = EXPORT_CTR_NAND; if(IsExportSucceeded())
{
s_BackupState = EXPORT_CTR_NAND;
}
else
{
s_BackupState = FAIL;
}
} }
} }
break; break;
@ -235,17 +258,23 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (continueBackup && IsExportThreadFinished()) if (continueBackup && IsExportThreadFinished())
{ {
FinalizeExportThread(); FinalizeExportThread();
COMMON_LOGGER("Export NAND Data Finished.\n"); if (IsExportSucceeded())
if(GetProgress() > 99)
{ {
s_BackupState = DELETE_NIM; COMMON_LOGGER("Export NAND Data Finished.\n");
if (GetProgress() > 99)
{
s_BackupState = DELETE_NIM;
}
else
{
s_BackupState = FAIL;
}
} }
else else
{ {
s_BackupState = FAIL; s_BackupState = FAIL;
} }
} }
} }
break; break;
@ -253,8 +282,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
// nimのシステムセーブデータ削除 // nimのシステムセーブデータ削除
case DELETE_NIM: case DELETE_NIM:
{ {
DeleteNimSaveData(); if(DeleteNimSaveData())
s_BackupState = DONE; {
s_BackupState = DONE;
}
else
{
s_BackupState = FAIL;
}
} }
break; break;
@ -318,7 +354,7 @@ void OnSdEjected()
{ {
s_BackupState = FINISHED; s_BackupState = FINISHED;
} }
else else if(s_BackupState != FAIL)
{ {
common::InitializeFileCheck(); common::InitializeFileCheck();
InitializeState(); InitializeState();

193
trunk/ConsoleDataMigration/sources/ConsoleBackup/Exporter.cpp
View File

@ -44,7 +44,6 @@
#include "FileTransfer.h" #include "FileTransfer.h"
#include "common_Types.h" #include "common_Types.h"
#include "Aes_define.h" #include "Aes_define.h"
#include "PlayHistoryManager.h"
#include "VersionDetect.h" #include "VersionDetect.h"
#include "Util.h" #include "Util.h"
@ -61,6 +60,7 @@ common::CfgCountryLanguage s_CountryLanguage;
const size_t EXPORT_THREAD_STACK_SIZE = 0x4000; const size_t EXPORT_THREAD_STACK_SIZE = 0x4000;
nn::os::Thread s_ExportThread; nn::os::Thread s_ExportThread;
nn::os::StackBuffer<EXPORT_THREAD_STACK_SIZE> s_ExportThreadStack; nn::os::StackBuffer<EXPORT_THREAD_STACK_SIZE> s_ExportThreadStack;
bool s_IsExportSucceeded;
wchar_t s_RootName[256]; wchar_t s_RootName[256];
@ -156,12 +156,13 @@ void DeleteTrash(std::wstring currentDirectory)
common::SdMountManager::Unmount(); common::SdMountManager::Unmount();
} }
void WriteTwlTitleList(std::vector<std::wstring>& programIdList) nn::Result WriteTwlTitleList(std::vector<std::wstring>& programIdList)
{ {
COMMON_LOGGER("Export TwlTitle List.\n"); COMMON_LOGGER("Export TwlTitle List.\n");
size_t heapSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t heapSize = common::GetAllocatableSize();
char* titleListBuf = reinterpret_cast<char*> (common::HeapManager::GetHeap()->Allocate(heapSize)); common::HeapManager manager(heapSize);
char* titleListBuf = reinterpret_cast<char*> (manager.GetAddr());
size_t writeSize = 0; size_t writeSize = 0;
if (titleListBuf != NULL) if (titleListBuf != NULL)
@ -175,8 +176,7 @@ void WriteTwlTitleList(std::vector<std::wstring>& programIdList)
} }
nn::Result result = s_SdWriter.WriteBufWithCmac(common::TWL_TITLELIST_PATHNAME, titleListBuf, writeSize); nn::Result result = s_SdWriter.WriteBufWithCmac(common::TWL_TITLELIST_PATHNAME, titleListBuf, writeSize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); return result;
common::HeapManager::GetHeap()->Free(titleListBuf);
} }
@ -264,7 +264,8 @@ void WriteIvs(common::HardwareStateManager& manager)
void* enc; void* enc;
nn::Result result; nn::Result result;
enc = common::HeapManager::GetHeap()->Allocate(size); common::HeapManager ivsHeap(size);
enc = ivsHeap.GetAddr();
if(enc != NULL) if(enc != NULL)
{ {
// AES暗号化する // AES暗号化する
@ -276,8 +277,6 @@ void WriteIvs(common::HardwareStateManager& manager)
swAesCtrContest.Encrypt(enc, ivs, size); swAesCtrContest.Encrypt(enc, ivs, size);
s_SdWriter.WriteBufWithCmac(common::IVS_PATHNAME, enc, size); s_SdWriter.WriteBufWithCmac(common::IVS_PATHNAME, enc, size);
common::HeapManager::GetHeap()->Free(enc);
} }
} }
@ -458,27 +457,32 @@ void WriteTwlData(enum common::TWL_PATH_INDEX path)
NN_ASSERT(path < common::TWL_PATHNAME_MAX); NN_ASSERT(path < common::TWL_PATHNAME_MAX);
nn::Result result; nn::Result result;
s_IsExportSucceeded = true;
result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[path], common::TWL_FS_ARCHIVE_KIND[path]); result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[path], common::TWL_FS_ARCHIVE_KIND[path]);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
result = common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t bufSize = common::GetAllocatableSize();
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
u32 fileNum = 0; u32 fileNum = 0;
s64 fileSize = 0; s64 fileSize = 0;
common::CalculateFileNum(::std::wstring(common::NAND_TWL_ROOT_PATHNAME_WITH_SLASH_TABLE[path]), fileNum, fileSize); result = common::CalculateFileNum(::std::wstring(common::NAND_TWL_ROOT_PATHNAME_WITH_SLASH_TABLE[path]), fileNum, fileSize);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
nn::fs::Unmount(common::NAND_ARCHIVE_NAME); nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
NN_LOG("File Number = %d\n", fileNum); NN_LOG("File Number = %d\n", fileNum);
NN_LOG("File Size = %d\n", fileSize); NN_LOG("File Size = %d\n", fileSize);
// 進捗表示用 // 進捗表示用
common::InitializeTransferProgress(fileSize); common::InitializeTransferProgress(fileSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE); common::HeapManager writeHeap(bufSize, AES_BLOCK_SIZE);
void* buf = writeHeap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
nn::fs::FileOutputStream list; nn::fs::FileOutputStream list;
@ -497,31 +501,38 @@ void WriteTwlData(enum common::TWL_PATH_INDEX path)
::std::mbstowcs(archiveName, common::TWL_ARCHIVE_NAME_TABLE[path], ::std::mbstowcs(archiveName, common::TWL_ARCHIVE_NAME_TABLE[path],
std::strlen(common::TWL_ARCHIVE_NAME_TABLE[path]) + 1); std::strlen(common::TWL_ARCHIVE_NAME_TABLE[path]) + 1);
std::wstring archiveString(archiveName); std::wstring archiveString(archiveName);
common::CopyDirectory( if(!common::CopyDirectory(
NULL, NULL,
(archiveString + ::std::wstring(L"/")).c_str(), (archiveString + ::std::wstring(L"/")).c_str(),
(common::SDMC_ROOT_DIRECTORY_PATH + ::std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str(), (common::SDMC_ROOT_DIRECTORY_PATH + ::std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str(),
buf, bufSize, true, &list, &s_FileListContext); buf, bufSize, true, &list, &s_FileListContext))
{
s_IsExportSucceeded = false;
return;
}
} }
list.TryFlush(); list.TryFlush();
list.Finalize(); list.Finalize();
} }
} }
common::HeapManager::GetHeap()->Free(buf); else
{
s_IsExportSucceeded = false;
}
} }
common::SdMountManager::Unmount(); common::SdMountManager::Unmount();
nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[path]); nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[path]);
} }
void CalculateTwlSaveData(std::vector<common::SavePathInfo>* fileList, s64* fileSize) nn::Result CalculateTwlSaveData(std::vector<common::SavePathInfo>* fileList, s64* fileSize)
{ {
NN_NULL_ASSERT(fileList); NN_NULL_ASSERT(fileList);
NN_NULL_ASSERT(fileSize); NN_NULL_ASSERT(fileSize);
*fileSize = 0; *fileSize = 0;
nn::Result result; nn::Result result = nn::ResultSuccess();
for (std::vector<common::SavePathInfo>::iterator it = fileList->begin(); it != fileList->end(); it++) for (std::vector<common::SavePathInfo>::iterator it = fileList->begin(); it != fileList->end(); it++)
{ {
@ -541,28 +552,33 @@ void CalculateTwlSaveData(std::vector<common::SavePathInfo>* fileList, s64* file
} }
} }
return result;
} }
void WriteTwlSaveData() void WriteTwlSaveData()
{ {
nn::Result result; nn::Result result;
s_IsExportSucceeded = true;
std::vector<common::SavePathInfo> fileList; std::vector<common::SavePathInfo> fileList;
std::vector<std::wstring> programIdList; std::vector<std::wstring> programIdList;
COMMON_LOGGER("Export Twl Save Data.\n"); COMMON_LOGGER("Export Twl Save Data.\n");
// ディレクトリ作成 // ディレクトリ作成
s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + result = s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) +
std::wstring(common::SD_SAVEDATA_TWL_ROOT_NAME)).c_str()); std::wstring(common::SD_SAVEDATA_TWL_ROOT_NAME)).c_str());
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
// セーブデータを含むディレクトリ一覧を生成 // セーブデータを含むディレクトリ一覧を生成
result = nn::fs::MountSpecialArchive(common::NAND_TWL_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_TWL_NAND); result = nn::fs::MountSpecialArchive(common::NAND_TWL_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_TWL_NAND);
COMMON_LOGGER_RESULT_IF_FAILED(result); COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
ListTwlSaveDataDirectory(std::wstring(common::NAND_TWL_DATA_ROOT_PATHNAME_WITHOUT_SLASH), 0, &fileList, & programIdList); ListTwlSaveDataDirectory(std::wstring(common::NAND_TWL_DATA_ROOT_PATHNAME_WITHOUT_SLASH), 0, &fileList, & programIdList);
NN_LOG("No Twl Savedata\n"); NN_LOG("No Twl Savedata\n");
if(fileList.size() == 0) if(fileList.size() == 0)
{ {
s_IsExportSucceeded = true;
return; return;
} }
@ -572,73 +588,75 @@ void WriteTwlSaveData()
NN_LOG("%ls\n", it->name.c_str()); NN_LOG("%ls\n", it->name.c_str());
} }
WriteTwlTitleList(programIdList); result = WriteTwlTitleList(programIdList);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
// 合計サイズ取得 // 合計サイズ取得
s64 fileSize; s64 fileSize;
CalculateTwlSaveData(&fileList, &fileSize); result = CalculateTwlSaveData(&fileList, &fileSize);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
common::InitializeTransferProgress(fileSize); common::InitializeTransferProgress(fileSize);
NN_LOG("\n"); NN_LOG("\n");
// SDに書き出し // SDに書き出し
result = common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t bufSize = common::GetAllocatableSize();
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE); common::HeapManager writeHeap(bufSize, AES_BLOCK_SIZE);
void* buf = writeHeap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
nn::fs::FileOutputStream list; nn::fs::FileOutputStream list;
result = list.TryInitialize(common::FILE_LIST_PATHNAME, true); result = list.TryInitialize(common::FILE_LIST_PATHNAME, true);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
if (result.IsSuccess())
result = list.TryGetSize(&fileSize);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
// 末尾に移動
result = list.TrySetPosition(fileSize);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
wchar_t archiveName[nn::fs::MAX_FILE_PATH_LENGTH];
::std::mbstowcs(archiveName, common::NAND_TWL_ARCHIVE_NAME, std::strlen(common::NAND_TWL_ARCHIVE_NAME) + 1);
std::wstring archiveString(archiveName);
for (std::vector<common::SavePathInfo>::reverse_iterator it = fileList.rbegin(); it != fileList.rend(); it++)
{ {
result = list.TryGetSize(&fileSize); // twln:/title/をsdmc:/CTR_Console_Repair/TWLBackup/に置換
if (result.IsSuccess()) std::wstring toPath(it->name.c_str());
toPath.replace(0, std::wcslen(common::NAND_TWL_DATA_ROOT_PATHNAME_WITHOUT_SLASH) + 1,
std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + std::wstring(common::SD_SAVEDATA_TWL_ROOT_NAME));
if (it->isDirectory)
{ {
// 末尾に移動 if(!common::ExportTwlSaveDirectory(toPath.c_str(), &list, &s_FileListContext))
result = list.TrySetPosition(fileSize);
if (result.IsSuccess())
{ {
wchar_t archiveName[nn::fs::MAX_FILE_PATH_LENGTH]; s_IsExportSucceeded = false;
::std::mbstowcs(archiveName, common::NAND_TWL_ARCHIVE_NAME, return;
std::strlen(common::NAND_TWL_ARCHIVE_NAME) + 1); }
std::wstring archiveString(archiveName); }
else
for (std::vector<common::SavePathInfo>::reverse_iterator it = fileList.rbegin(); it {
!= fileList.rend(); it++) if(!common::ExportTwlSaveFile(it->name.c_str(), toPath.c_str(), buf, bufSize, &list, &s_FileListContext))
{ {
// twln:/title/をsdmc:/CTR_Console_Repair/TWLBackup/に置換 s_IsExportSucceeded = false;
std::wstring toPath(it->name.c_str()); return;
toPath.replace(
0,
std::wcslen(common::NAND_TWL_DATA_ROOT_PATHNAME_WITHOUT_SLASH) + 1,
std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + std::wstring(
common::SD_SAVEDATA_TWL_ROOT_NAME));
if(it->isDirectory)
{
common::ExportTwlSaveDirectory(toPath.c_str(), &list, &s_FileListContext);
}
else
{
common::ExportTwlSaveFile(it->name.c_str(), toPath.c_str(), buf, bufSize, &list,
&s_FileListContext);
}
}
} }
list.TryFlush();
list.Finalize();
} }
} }
common::HeapManager::GetHeap()->Free(buf); result = list.TryFlush();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
list.Finalize();
} }
common::SdMountManager::Unmount(); result = common::SdMountManager::Unmount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
nn::fs::Unmount( common::NAND_TWL_ARCHIVE_NAME); result = nn::fs::Unmount(common::NAND_TWL_ARCHIVE_NAME);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded);
} }
void WriteTwlPhotoData() void WriteTwlPhotoData()
@ -717,16 +735,18 @@ void WriteMcuRtcData(common::HardwareStateManager& manager)
void ExportThreadFunc() void ExportThreadFunc()
{ {
nn::Result result; nn::Result result;
s_IsExportSucceeded = true;
result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
result = common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t bufSize = common::GetAllocatableSize();
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE); common::HeapManager writeHeap(bufSize, AES_BLOCK_SIZE);
void* buf = writeHeap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
nn::fs::FileOutputStream list; nn::fs::FileOutputStream list;
@ -742,12 +762,16 @@ void ExportThreadFunc()
result = list.TrySetPosition(fileSize); result = list.TrySetPosition(fileSize);
if (result.IsSuccess()) if (result.IsSuccess())
{ {
common::CopyDirectory( if(!common::CopyDirectory(
NULL, NULL,
::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH).c_str(), ::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH).c_str(),
(std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring( (std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(
common::SD_SAVEDATA_ROOT_NAME)).c_str(), buf, bufSize, true, &list, common::SD_SAVEDATA_ROOT_NAME)).c_str(), buf, bufSize, true, &list,
&s_FileListContext); &s_FileListContext))
{
s_IsExportSucceeded = false;
return;
}
AddCmac(&list, &s_FileListContext); AddCmac(&list, &s_FileListContext);
list.TryFlush(); list.TryFlush();
@ -755,7 +779,6 @@ void ExportThreadFunc()
} }
} }
} }
common::HeapManager::GetHeap()->Free(buf);
} }
common::SdMountManager::Unmount(); common::SdMountManager::Unmount();
@ -816,15 +839,7 @@ void WriteVersionData(common::HardwareStateManager& manager)
s_SdWriter.WriteBufWithCmac(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef)); s_SdWriter.WriteBufWithCmac(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef));
} }
void WritePlayHistory() bool DeleteNimSaveData()
{
common::PlayHistoryManager historyManager;
COMMON_LOGGER("Export PlayHistory\n");
historyManager.Export();
}
void DeleteNimSaveData()
{ {
nn::Result result; nn::Result result;
::std::wstring nimSaveDataPath = ::std::wstring nimSaveDataPath =
@ -834,13 +849,21 @@ void DeleteNimSaveData()
::std::wstring(L"/") + ::std::wstring(L"/") +
std::wstring(common::NIM_SAVEDATA_DIRECTORY_NAME); std::wstring(common::NIM_SAVEDATA_DIRECTORY_NAME);
common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
NN_LOG("%ls\n", nimSaveDataPath.c_str()); NN_LOG("%ls\n", nimSaveDataPath.c_str());
result = nn::fs::TryDeleteDirectoryRecursively(nimSaveDataPath.c_str()); result = nn::fs::TryDeleteDirectoryRecursively(nimSaveDataPath.c_str());
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); if (result.IsFailure() && !nn::fs::ResultNotFound::Includes(result))
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
common::SdMountManager::Unmount(); result = common::SdMountManager::Unmount();
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
return true;
} }
void AddShutDownPtmEvent() void AddShutDownPtmEvent()
@ -880,9 +903,6 @@ void ExportData(common::HardwareStateManager& manager)
// IVSからセーブデータディレクトリ名を計算 // IVSからセーブデータディレクトリ名を計算
common::Util::GetSaveDataDirectoryRoot(systemSaveRoot, ivs, size); common::Util::GetSaveDataDirectoryRoot(systemSaveRoot, ivs, size);
// プレイ履歴をSDに書き出す
//WritePlayHistory();
// 電源断の履歴をptmに追加する // 電源断の履歴をptmに追加する
AddShutDownPtmEvent(); AddShutDownPtmEvent();
@ -909,6 +929,11 @@ bool IsExportThreadFinished()
return s_ExportThread.IsValid() && !s_ExportThread.IsAlive(); return s_ExportThread.IsValid() && !s_ExportThread.IsAlive();
} }
bool IsExportSucceeded()
{
return s_IsExportSucceeded;
}
//!@ brief ファイルにSHA256から計算したAES-CMACを付加します //!@ brief ファイルにSHA256から計算したAES-CMACを付加します
//!@ param[in] file CMACを付加したいInitialize済みのファイル //!@ param[in] file CMACを付加したいInitialize済みのファイル
//!@ param[in] context CMAC計算元のSHA256コンテキスト //!@ param[in] context CMAC計算元のSHA256コンテキスト

4
trunk/ConsoleDataMigration/sources/ConsoleBackup/Exporter.h
View File

@ -40,7 +40,7 @@ void ExportTwlSoundData();
void ExportData(common::HardwareStateManager& manager); void ExportData(common::HardwareStateManager& manager);
// NIMのセーブデータをSDカードから削除する // NIMのセーブデータをSDカードから削除する
void DeleteNimSaveData(); bool DeleteNimSaveData();
// 出力スレッドの進捗を返す // 出力スレッドの進捗を返す
u32 GetProgress(); u32 GetProgress();
@ -51,6 +51,8 @@ bool IsExportThreadFinished();
// 出力スレッドを終了する // 出力スレッドを終了する
void FinalizeExportThread(); void FinalizeExportThread();
// 出力が成功したかどうか
bool IsExportSucceeded();
} }

1
trunk/ConsoleDataMigration/sources/ConsoleBackup/OMakefile
View File

@ -38,7 +38,6 @@ SOURCES[] =
../common/LogConsole.cpp ../common/LogConsole.cpp
../common/CommonLogger.cpp ../common/CommonLogger.cpp
../common/SdMountManager.cpp ../common/SdMountManager.cpp
../common/PlayHistoryManager.cpp
../common/VersionDetect.cpp ../common/VersionDetect.cpp
../common/ResFont.cpp ../common/ResFont.cpp
../common/HardwareStateManager.cpp ../common/HardwareStateManager.cpp

5
trunk/ConsoleDataMigration/sources/ConsoleRestore/ConsoleRestore.cpp
View File

@ -131,10 +131,11 @@ extern "C" void nnMain(void)
nn::am::InitializeForSystemMenu(); nn::am::InitializeForSystemMenu();
// ヒープの確保 // ヒープの確保
common::HeapManager::GetHeap()->Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR); common::InitializeHeap();
// RenderSystem の準備 // RenderSystem の準備
uptr heapForGx = reinterpret_cast<uptr>(common::HeapManager::GetHeap()->Allocate(s_GxHeapSize)); common::HeapManager gxHeap(s_GxHeapSize);
uptr heapForGx = reinterpret_cast<uptr>(gxHeap.GetAddr());
s_RenderSystem.Initialize(heapForGx, s_GxHeapSize); s_RenderSystem.Initialize(heapForGx, s_GxHeapSize);
// ResFontの初期化 // ResFontの初期化

37
trunk/ConsoleDataMigration/sources/ConsoleRestore/Controller.cpp
View File

@ -1166,7 +1166,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (IsImportThreadFinished()) if (IsImportThreadFinished())
{ {
FinalizeImportThread(); FinalizeImportThread();
s_RestoreState = RESTORE_TWL_PHOTO; if(IsImportSucceeded())
{
s_RestoreState = RESTORE_TWL_PHOTO;
}
else
{
s_RestoreState = FAIL;
}
} }
} }
break; break;
@ -1188,7 +1196,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (IsImportThreadFinished()) if (IsImportThreadFinished())
{ {
FinalizeImportThread(); FinalizeImportThread();
s_RestoreState = RESTORE_IN_PROGRESS; if(IsImportSucceeded())
{
s_RestoreState = RESTORE_IN_PROGRESS;
}
else
{
s_RestoreState = FAIL;
}
} }
} }
break; break;
@ -1213,17 +1229,24 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
// 処理が完了した // 処理が完了した
if (!NeedsAcAdater(manager) && IsImportThreadFinished()) if (!NeedsAcAdater(manager) && IsImportThreadFinished())
{ {
COMMON_LOGGER("Import NAND Data Finished.\n"); if (IsImportSucceeded())
if (GetProgress() > 99)
{ {
s_RestoreState = POST_RESTORE;
COMMON_LOGGER("Import NAND Data Finished.\n");
if (GetProgress() > 99)
{
s_RestoreState = POST_RESTORE;
}
else
{
s_RestoreState = FAIL;
}
} }
else else
{ {
s_RestoreState = FAIL; s_RestoreState = FAIL;
} }
} }
} }
break; break;

143
trunk/ConsoleDataMigration/sources/ConsoleRestore/Importer.cpp
View File

@ -45,7 +45,6 @@
#include "common_Types.h" #include "common_Types.h"
#include "Aes_define.h" #include "Aes_define.h"
#include "configLoader.h" #include "configLoader.h"
#include "PlayHistoryManager.h"
#include "FileChecker.h" #include "FileChecker.h"
#include "VersionDetect.h" #include "VersionDetect.h"
@ -59,6 +58,7 @@ namespace
const size_t IMPORT_THREAD_STACK_SIZE = 0x4000; const size_t IMPORT_THREAD_STACK_SIZE = 0x4000;
nn::os::Thread s_ImportThread; nn::os::Thread s_ImportThread;
nn::os::StackBuffer<IMPORT_THREAD_STACK_SIZE> s_ImportThreadStack; nn::os::StackBuffer<IMPORT_THREAD_STACK_SIZE> s_ImportThreadStack;
bool s_IsImportSucceeded;
const size_t TIME_ZONE_LENGTH = 9; // "+23:45" const size_t TIME_ZONE_LENGTH = 9; // "+23:45"
char s_TimeZoneStr[TIME_ZONE_LENGTH]; char s_TimeZoneStr[TIME_ZONE_LENGTH];
@ -230,7 +230,8 @@ nn::Result ReadSerialNumber(u8* serial)
size_t readSize; size_t readSize;
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
size_t bufSize = 1024; size_t bufSize = 1024;
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager readHeap(bufSize);
void* buf = readHeap.GetAddr();
if(buf != NULL) if(buf != NULL)
{ {
result = sdReader.ReadBufWithCmac(common::SERIAL_PATHNAME, buf, bufSize, &readSize); result = sdReader.ReadBufWithCmac(common::SERIAL_PATHNAME, buf, bufSize, &readSize);
@ -240,7 +241,6 @@ nn::Result ReadSerialNumber(u8* serial)
std::memcpy(serial, s_SerialNo, sizeof(s_SerialNo)); std::memcpy(serial, s_SerialNo, sizeof(s_SerialNo));
s_ReadSerialNumber = true; s_ReadSerialNumber = true;
} }
common::HeapManager::GetHeap()->Free(buf);
} }
else else
{ {
@ -265,7 +265,8 @@ nn::Result EqualsDeviceIdFileandDeviceId(common::HardwareStateManager& manager)
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
size_t totalSize; size_t totalSize;
size_t bufSize = 1024; size_t bufSize = 1024;
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
result = sdReader.ReadBufWithCmac(common::DEVICE_ID_PATHNAME, buf, bufSize, &totalSize); result = sdReader.ReadBufWithCmac(common::DEVICE_ID_PATHNAME, buf, bufSize, &totalSize);
@ -284,7 +285,6 @@ nn::Result EqualsDeviceIdFileandDeviceId(common::HardwareStateManager& manager)
nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_INVALID_RESULT_VALUE); nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_INVALID_RESULT_VALUE);
} }
} }
common::HeapManager::GetHeap()->Free(buf);
} }
else else
{ {
@ -313,7 +313,8 @@ nn::Result EqualsRegionDataandRegion()
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
size_t readSize; size_t readSize;
size_t bufSize = 1024; size_t bufSize = 1024;
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
result = sdReader.ReadBufWithCmac(common::REGION_DATA_PATHNAME, buf, bufSize, &readSize); result = sdReader.ReadBufWithCmac(common::REGION_DATA_PATHNAME, buf, bufSize, &readSize);
@ -331,7 +332,6 @@ nn::Result EqualsRegionDataandRegion()
nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_INVALID_RESULT_VALUE); nn::Result::MODULE_COMMON, nn::Result::DESCRIPTION_INVALID_RESULT_VALUE);
} }
} }
common::HeapManager::GetHeap()->Free(buf);
} }
else else
{ {
@ -387,7 +387,8 @@ nn::Result ImportCountryLanguageData()
if (common::ExistsCountryLanguageFile()) if (common::ExistsCountryLanguageFile())
{ {
size_t bufSize = 1024; size_t bufSize = 1024;
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
@ -401,7 +402,6 @@ nn::Result ImportCountryLanguageData()
SetLanguage(reinterpret_cast<common::CfgCountryLanguage*> (buf)->language); SetLanguage(reinterpret_cast<common::CfgCountryLanguage*> (buf)->language);
} }
common::HeapManager::GetHeap()->Free(buf);
NN_UTIL_RETURN_IF_FAILED(result); NN_UTIL_RETURN_IF_FAILED(result);
} }
@ -483,7 +483,8 @@ nn::Result ImportMcuRtc(common::HardwareStateManager& manager)
size_t bufSize = 1024; size_t bufSize = 1024;
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
@ -523,7 +524,6 @@ nn::Result ImportMcuRtc(common::HardwareStateManager& manager)
} }
} }
common::HeapManager::GetHeap()->Free(buf);
NN_UTIL_RETURN_IF_FAILED(result); NN_UTIL_RETURN_IF_FAILED(result);
} }
else else
@ -628,7 +628,8 @@ nn::Result ImportIvs()
nn::fs::FileOutputStream fos; nn::fs::FileOutputStream fos;
size_t bufSize = 1024; size_t bufSize = 1024;
void* enc = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager encHeap(bufSize);
void* enc = encHeap.GetAddr();
if (enc != NULL) if (enc != NULL)
{ {
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
@ -641,7 +642,8 @@ nn::Result ImportIvs()
result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND);
if (result.IsSuccess()) if (result.IsSuccess())
{ {
void *dec = common::HeapManager::GetHeap()->Allocate(readSize); common::HeapManager decHeap(bufSize);
void *dec = decHeap.GetAddr();
if (dec != NULL) if (dec != NULL)
{ {
// AES復号化する // AES復号化する
@ -665,7 +667,6 @@ nn::Result ImportIvs()
} }
} }
} }
common::HeapManager::GetHeap()->Free(dec);
} }
else else
{ {
@ -677,7 +678,6 @@ nn::Result ImportIvs()
} }
nn::fs::Unmount(common::NAND_ARCHIVE_NAME); nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
} }
common::HeapManager::GetHeap()->Free(enc);
NN_UTIL_RETURN_IF_FAILED(result); NN_UTIL_RETURN_IF_FAILED(result);
} }
else else
@ -698,31 +698,36 @@ bool ImportIvsData()
void ImportThreadFunc() void ImportThreadFunc()
{ {
nn::Result result; nn::Result result;
s_IsImportSucceeded = true;
result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND); result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
result = common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t bufSize = common::GetAllocatableSize();
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
if(!common::CopyDirectory(
common::CopyDirectory(
&s_FileLists, &s_FileLists,
(::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_SAVEDATA_ROOT_NAME)).c_str(), (::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_SAVEDATA_ROOT_NAME)).c_str(),
common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH, common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH,
buf, bufSize, false, NULL, NULL); buf, bufSize, false, NULL, NULL))
{
common::HeapManager::GetHeap()->Free(buf); s_IsImportSucceeded = false;
return;
}
} }
common::SdMountManager::Unmount(); common::SdMountManager::Unmount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
nn::fs::Unmount(common::NAND_ARCHIVE_NAME); nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
NN_LOG("Import Thread Finalize\n"); NN_LOG("Import Thread Finalize\n");
} }
@ -752,10 +757,11 @@ nn::Result ImportNorData()
nn::cfg::nor::CTR::Initialize(); nn::cfg::nor::CTR::Initialize();
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize() / 2; size_t bufSize = common::GetAllocatableSize() / 2;
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
@ -813,8 +819,6 @@ nn::Result ImportNorData()
} }
} }
common::HeapManager::GetHeap()->Free(buf);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
NN_UTIL_RETURN_IF_FAILED(result); NN_UTIL_RETURN_IF_FAILED(result);
} }
@ -836,10 +840,11 @@ nn::Result ReadVersionData()
nn::Result result = nn::ResultSuccess(); nn::Result result = nn::ResultSuccess();
std::memset(&s_SDVersionData, 0, sizeof(common::VerDef)); std::memset(&s_SDVersionData, 0, sizeof(common::VerDef));
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize() / 2; size_t bufSize = common::GetAllocatableSize() / 2;
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
@ -854,11 +859,8 @@ nn::Result ReadVersionData()
s_SDVersionData.cup.minorVersion, s_SDVersionData.cup.minorVersion,
s_SDVersionData.cup.microVersion, s_SDVersionData.cup.microVersion,
s_SDVersionData.nup.majorVersion); s_SDVersionData.nup.majorVersion);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
} }
common::HeapManager::GetHeap()->Free(buf);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
NN_UTIL_RETURN_IF_FAILED(result); NN_UTIL_RETURN_IF_FAILED(result);
} }
@ -1075,7 +1077,8 @@ bool ReadSetting(bool* nupOnly, bool* getIvs, bool* checkSd, bool* skipNup)
common::SdMountManager::Mount(); common::SdMountManager::Mount();
size_t size = 10240; size_t size = 10240;
void* heapAddr = common::HeapManager::GetHeap()->Allocate(size); common::HeapManager heap(size);
void* heapAddr = heap.GetAddr();
if(heapAddr != NULL) if(heapAddr != NULL)
{ {
@ -1439,7 +1442,6 @@ bool ReadSetting(bool* nupOnly, bool* getIvs, bool* checkSd, bool* skipNup)
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
retval = false; retval = false;
} }
common::HeapManager::GetHeap()->Free(heapAddr);
} }
else else
{ {
@ -1472,67 +1474,80 @@ void ImportTwlData(enum common::TWL_PATH_INDEX path, s64 fileSize)
NN_ASSERT(path < common::TWL_PATHNAME_MAX); NN_ASSERT(path < common::TWL_PATHNAME_MAX);
nn::Result result; nn::Result result;
s_IsImportSucceeded = true;
result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[path], common::TWL_FS_ARCHIVE_KIND[path]); result = nn::fs::MountSpecialArchive(common::TWL_ARCHIVE_NAME_TABLE[path], common::TWL_FS_ARCHIVE_KIND[path]);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
result = common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t bufSize = common::GetAllocatableSize();
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
// ファイルサイズ設定 // ファイルサイズ設定
common::InitializeTransferProgress(fileSize); common::InitializeTransferProgress(fileSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE); common::HeapManager heap(bufSize, AES_BLOCK_SIZE);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
wchar_t archiveName[nn::fs::MAX_FILE_PATH_LENGTH]; wchar_t archiveName[nn::fs::MAX_FILE_PATH_LENGTH];
::std::mbstowcs(archiveName, common::TWL_ARCHIVE_NAME_TABLE[path], std::strlen(common::TWL_ARCHIVE_NAME_TABLE[path]) + 1); ::std::mbstowcs(archiveName, common::TWL_ARCHIVE_NAME_TABLE[path], std::strlen(common::TWL_ARCHIVE_NAME_TABLE[path]) + 1);
std::wstring archiveString(archiveName); std::wstring archiveString(archiveName);
common::CopyDirectory( if(!common::CopyDirectory(
&s_FileLists, &s_FileLists,
(::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str(), (::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str(),
(archiveString + ::std::wstring(L"/")).c_str(), (archiveString + ::std::wstring(L"/")).c_str(),
buf, bufSize, false, NULL, NULL); buf, bufSize, false, NULL, NULL))
{
common::HeapManager::GetHeap()->Free(buf); s_IsImportSucceeded = false;
return;
}
} }
common::SdMountManager::Unmount(); common::SdMountManager::Unmount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[path]); nn::fs::Unmount(common::TWL_ARCHIVE_NAME_TABLE[path]);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
} }
void ImportTwlTitleSaveData(s64 fileSize) void ImportTwlTitleSaveData(s64 fileSize)
{ {
nn::Result result; nn::Result result;
s_IsImportSucceeded = true;
result = nn::fs::MountSpecialArchive(common::NAND_TWL_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_TWL_NAND); result = nn::fs::MountSpecialArchive(common::NAND_TWL_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_TWL_NAND);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
result = common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t bufSize = common::GetAllocatableSize();
NN_LOG("AllocatableSize = %d\n", bufSize); NN_LOG("AllocatableSize = %d\n", bufSize);
// ファイルサイズ設定 // ファイルサイズ設定
common::InitializeTransferProgress(fileSize); common::InitializeTransferProgress(fileSize);
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE); common::HeapManager heap(bufSize, AES_BLOCK_SIZE);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
common::CopyDirectory( if(!common::CopyDirectory(
&s_FileLists, &s_FileLists,
(::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_SAVEDATA_TWL_ROOT_NAME)).c_str(), (::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(common::SD_SAVEDATA_TWL_ROOT_NAME)).c_str(),
(std::wstring(common::NAND_TWL_DATA_ROOT_PATHNAME_WITHOUT_SLASH) + ::std::wstring(L"/")).c_str(), (std::wstring(common::NAND_TWL_DATA_ROOT_PATHNAME_WITHOUT_SLASH) + ::std::wstring(L"/")).c_str(),
buf, bufSize, false, NULL, NULL); buf, bufSize, false, NULL, NULL))
{
common::HeapManager::GetHeap()->Free(buf); s_IsImportSucceeded = false;
return;
}
} }
common::SdMountManager::Unmount(); common::SdMountManager::Unmount();
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
nn::fs::Unmount(common::NAND_TWL_ARCHIVE_NAME); nn::fs::Unmount(common::NAND_TWL_ARCHIVE_NAME);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
} }
void ImportTwlPhotoDataFunc() void ImportTwlPhotoDataFunc()
@ -1576,19 +1591,6 @@ void ClearFileReadResult()
s_ReadSerialNumber = false; s_ReadSerialNumber = false;
} }
void ImportPlayHistoryThreadFunc()
{
common::PlayHistoryManager historyManager;
COMMON_LOGGER("Import PlayHistory\n");
historyManager.Import();
}
void ImportPlayHistory()
{
s_ImportThread.Start(ImportPlayHistoryThreadFunc, s_ImportThreadStack);
}
void ExportCalData() void ExportCalData()
{ {
using namespace nn::cfg::CTR::detail; using namespace nn::cfg::CTR::detail;
@ -1648,8 +1650,9 @@ nn::Result ImportCalData(common::CfgCalData *data)
common::SdMountManager::Mount(); common::SdMountManager::Mount();
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize() / 2; size_t bufSize = common::GetAllocatableSize() / 2;
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize); common::HeapManager heap(bufSize);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
common::SdReaderWriter sdReader; common::SdReaderWriter sdReader;
@ -1661,7 +1664,6 @@ nn::Result ImportCalData(common::CfgCalData *data)
// SDから読み出し成功 // SDから読み出し成功
std::memcpy(data, buf, readSize); std::memcpy(data, buf, readSize);
} }
common::HeapManager::GetHeap()->Free(buf);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
NN_UTIL_RETURN_IF_FAILED(result); NN_UTIL_RETURN_IF_FAILED(result);
} }
@ -1765,7 +1767,8 @@ nn::Result ReadFileList(SdFileSize* sdFiles, common::ImportDataList* fileList)
file.Finalize(); file.Finalize();
} }
void* buf = common::HeapManager::GetHeap()->Allocate(fileSize); common::HeapManager heap(fileSize);
void* buf = heap.GetAddr();
if(buf != NULL) if(buf != NULL)
{ {
result = sdReader.ReadBufWithCmac(common::FILE_LIST_PATHNAME, buf, fileSize, &readSize); result = sdReader.ReadBufWithCmac(common::FILE_LIST_PATHNAME, buf, fileSize, &readSize);
@ -1835,7 +1838,6 @@ nn::Result ReadFileList(SdFileSize* sdFiles, common::ImportDataList* fileList)
} }
} }
common::HeapManager::GetHeap()->Free(buf);
} }
else else
{ {
@ -1846,6 +1848,11 @@ nn::Result ReadFileList(SdFileSize* sdFiles, common::ImportDataList* fileList)
} }
bool IsImportSucceeded()
{
return s_IsImportSucceeded;
}
nn::Result ImportData() nn::Result ImportData()
{ {
static nn::Result result = nn::ResultSuccess(); static nn::Result result = nn::ResultSuccess();

3
trunk/ConsoleDataMigration/sources/ConsoleRestore/Importer.h
View File

@ -157,6 +157,9 @@ bool ExistsIvsDirectory(std::string& ivsRoot);
// SDカードのIVSデータを書き込む // SDカードのIVSデータを書き込む
bool ImportIvsData(); bool ImportIvsData();
// 書き込みが成功したかどうか
bool IsImportSucceeded();
} }
#endif /* IMPORTER_H_ */ #endif /* IMPORTER_H_ */

1
trunk/ConsoleDataMigration/sources/ConsoleRestore/OMakefile
View File

@ -43,7 +43,6 @@ SOURCES[] =
../common/CommonLogger.cpp ../common/CommonLogger.cpp
../common/SdMountManager.cpp ../common/SdMountManager.cpp
../common/configLoader.cpp ../common/configLoader.cpp
../common/PlayHistoryManager.cpp
../common/VersionDetect.cpp ../common/VersionDetect.cpp
../common/ResFont.cpp ../common/ResFont.cpp
../common/HardwareStateManager.cpp ../common/HardwareStateManager.cpp

6
trunk/ConsoleDataMigration/sources/ConsoleRestore/TitleDownloader.cpp
View File

@ -219,8 +219,9 @@ nn::Result TitleDownloader::ListUp()
{ {
COMMON_LOGGER("Read TwlTitle List.\n"); COMMON_LOGGER("Read TwlTitle List.\n");
size_t heapSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t heapSize = common::GetAllocatableSize();
char* titleListBuf = reinterpret_cast<char*> (common::HeapManager::GetHeap()->Allocate(heapSize)); common::HeapManager heap(heapSize);
char* titleListBuf = reinterpret_cast<char*> (heap.GetAddr());
size_t readSize = 0; size_t readSize = 0;
if (titleListBuf != NULL) if (titleListBuf != NULL)
@ -247,7 +248,6 @@ nn::Result TitleDownloader::ListUp()
} }
} }
COMMON_LOGGER("%d Title(s) found.\n", m_TwlTiteNum); COMMON_LOGGER("%d Title(s) found.\n", m_TwlTiteNum);
common::HeapManager::GetHeap()->Free(titleListBuf);
} }
else else
{ {

29
trunk/ConsoleDataMigration/sources/common/CommonLogger.h
View File

@ -64,6 +64,35 @@
COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \ COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \
} \ } \
#define COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result) \
if(result.IsFailure()) \
{ \
COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \
return result; \
} \
#define COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result) \
if(result.IsFailure()) \
{ \
COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \
return false; \
} \
#define COMMON_LOGGER_RETURN_VOID_IF_FAILED(result) \
if(result.IsFailure()) \
{ \
COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \
return; \
} \
#define COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, setbool) \
if(result.IsFailure()) \
{ \
COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \
setbool = false; \
return; \
} \
namespace common namespace common
{ {

674
trunk/ConsoleDataMigration/sources/common/FileTransfer.cpp
View File

@ -44,7 +44,7 @@ bool VerifyMac(nn::fs::FileInputStream* sdFile, nn::fs::FileStream* nandFile, s6
bool ConfirmFile(nn::fs::FileInputStream* from_file, nn::fs::FileStream* to_file, s64 sdFileSize, s64 nandFileSize, bool ConfirmFile(nn::fs::FileInputStream* from_file, nn::fs::FileStream* to_file, s64 sdFileSize, s64 nandFileSize,
void* buf, size_t bufSize, const wchar_t* sdPath, const wchar_t* tmpPath, const wchar_t* truePath); void* buf, size_t bufSize, const wchar_t* sdPath, const wchar_t* tmpPath, const wchar_t* truePath);
void AddPkcsPadding(u8* paddingSize, void* buf, size_t bufSize, s32* readSize); void AddPkcsPadding(u8* paddingSize, void* buf, size_t bufSize, s32* readSize);
void AddPathNameAndUpdateContext(nn::fs::FileOutputStream* file, const wchar_t *str, s64 fileSize, bool AddPathNameAndUpdateContext(nn::fs::FileOutputStream* file, const wchar_t *str, s64 fileSize,
nn::crypto::Sha256Context* context); nn::crypto::Sha256Context* context);
const char* GetCharStr(const wchar_t* path) const char* GetCharStr(const wchar_t* path)
@ -65,48 +65,36 @@ nn::Result CalculateFileNum(std::wstring currentDirectory, u32& fileNum, s64& fi
std::vector<nn::fs::DirectoryEntry>::iterator entryIndex; std::vector<nn::fs::DirectoryEntry>::iterator entryIndex;
result = dir.TryInitialize(currentDirectory.c_str()); result = dir.TryInitialize(currentDirectory.c_str());
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
if(result.IsSuccess()) nn::fs::DirectoryEntry entry;
s32 numEntry;
for (;;)
{ {
nn::fs::DirectoryEntry entry; result = dir.TryRead(&numEntry, &entry, 1);
s32 numEntry; COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
for(;;) if (numEntry == 0)
{ {
result = dir.TryRead(&numEntry, &entry, 1); // カレントディレクトリを閉じる
if(result.IsFailure()) dir.Finalize();
{
dir.Finalize();
return result;
}
if(numEntry == 0)
{
// カレントディレクトリを閉じる
dir.Finalize();
// カレントディレクトリの子を開く // カレントディレクトリの子を開く
for(entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++) for (entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++)
{
if (entryIndex->attributes.isDirectory)
{ {
if(entryIndex->attributes.isDirectory) CalculateFileNum(currentDirectory + std::wstring(entryIndex->entryName) + std::wstring(L"/"),
{ fileNum, fileSize);
CalculateFileNum(currentDirectory + std::wstring(entryIndex->entryName) + std::wstring(L"/"), fileNum, fileSize);
}
} }
return nn::ResultSuccess();
} }
entryList.push_back(entry); return nn::ResultSuccess();
fileNum++;
fileSize+= entry.entrySize;
} }
}
else
{
NN_LOG("failed initialize directory\n");
dir.Finalize();
return result;
}
entryList.push_back(entry);
fileNum++;
fileSize += entry.entrySize;
}
} }
bool ExistsInList(ImportDataList* fileList, const wchar_t* path, bool isDirectory) bool ExistsInList(ImportDataList* fileList, const wchar_t* path, bool isDirectory)
@ -134,15 +122,15 @@ bool ExistsInList(ImportDataList* fileList, const wchar_t* path, bool isDirector
return returnValue; return returnValue;
} }
void ExportTwlSaveDirectory(const wchar_t* dirPath, nn::fs::FileOutputStream* list, bool ExportTwlSaveDirectory(const wchar_t* dirPath, nn::fs::FileOutputStream* list,
nn::crypto::Sha256Context* listContext) nn::crypto::Sha256Context* listContext)
{ {
NN_LOG("Create Directory %ls\n", dirPath); NN_LOG("Create Directory %ls\n", dirPath);
nn::Result result = nn::fs::TryCreateDirectory(dirPath); nn::Result result = nn::fs::TryCreateDirectory(dirPath);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
AddPathNameAndUpdateContext(list, dirPath, -1, listContext); return AddPathNameAndUpdateContext(list, dirPath, -1, listContext);
} }
bool ExportTwlSaveFile(const wchar_t* from_path, const wchar_t* to_path, void* buf, const size_t bufSize, bool ExportTwlSaveFile(const wchar_t* from_path, const wchar_t* to_path, void* buf, const size_t bufSize,
@ -164,138 +152,100 @@ bool ExportTwlSaveFile(const wchar_t* from_path, const wchar_t* to_path, void* b
// 読み込み対象ファイル開く // 読み込み対象ファイル開く
result = from_file.TryInitialize(from_path); result = from_file.TryInitialize(from_path);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (result.IsFailure()) // 読み込み対象ファイルのサイズ取得
result = from_file.TryGetSize(&filesize);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (!AddPathNameAndUpdateContext(list, to_path, filesize, listContext))
{ {
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false; return false;
} }
else
nn::crypto::SwAesCtrContext swAesCtrContext;
swAesCtrContext.Initialize(iv, common::key, sizeof(key));
size_t totalReadSize = 0;
nn::crypto::Sha256Context context;
context.Initialize();
// ファイルサイズをヘッダに書いておく
// 書き込み対象ファイル作成
result = nn::fs::TryCreateFile(to_path, filesize);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = to_file.TryInitialize(to_path,
nn::fs::OPEN_MODE_READ | nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
// フルパスをハッシュに含める
context.Update(from_path, std::wcslen(from_path) * sizeof(wchar_t));
BackupDataHeader header;
BackupDataHeader enc;
std::memset(&header, 0, sizeof(header));
std::memset(&enc, 0, sizeof(enc));
header.size = filesize;
result = swAesCtrContext.Encrypt(&enc, &header, sizeof(header));
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context.Update(&enc, sizeof(enc));
s32 writeSize;
result = to_file.TryWrite(&writeSize, &enc, sizeof(enc), false);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
while (1)
{ {
// 読み込み対象ファイルのサイズ取得 // バッファの後半半分を暗号・復号用に使う
result = from_file.TryGetSize(&filesize); result = from_file.TryRead(&readsize, buf, bufSize / 2);
if (result.IsFailure()) COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
totalReadSize += readsize;
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (readsize == 0)
{ {
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); NN_LOG("Add CMAC %ls\n", from_path);
return false; // SHA256を計算してCMACを付加する
bit8 sha256Hash[nn::crypto::Sha256Context::HASH_SIZE];
context.GetHash(sha256Hash);
bit8 cmac[nn::crypto::AES_CMAC_MAC_SIZE];
result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, nn::crypto::Sha256Context::HASH_SIZE,
common::cmacKey);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = to_file.TryWrite(&writesize, cmac, sizeof(cmac));
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = to_file.TryFlush();
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
break;
} }
else else
{ {
AddPathNameAndUpdateContext(list, to_path, filesize, listContext); NN_LOG("EncryptSize = %d\n", readsize);
nn::crypto::SwAesCtrContext swAesCtrContext; u8 paddingSize = 0;
swAesCtrContext.Initialize(iv, common::key, sizeof(key)); AddPkcsPadding(&paddingSize, reinterpret_cast<bit8*>(buf), bufSize / 2, &readsize);
size_t totalReadSize = 0; // 暗号化後SHA256を計算しつつ書き込み
nn::crypto::Sha256Context context; result = swAesCtrContext.Encrypt(reinterpret_cast<bit8*>(buf) + bufSize / 2, buf, readsize);
context.Initialize(); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context.Update(reinterpret_cast<bit8*>(buf) + bufSize / 2, readsize);
// ファイルサイズをヘッダに書いておく result = to_file.TryWrite(&writesize, reinterpret_cast<bit8*>(buf) + bufSize / 2, readsize, false);
// 書き込み対象ファイル作成 COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = nn::fs::TryCreateFile(to_path, filesize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
result = to_file.TryInitialize(to_path,
nn::fs::OPEN_MODE_READ | nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE);
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
// フルパスをハッシュに含める // 事前計算したファイルサイズに一致させるためパディング分減算
context.Update(from_path, std::wcslen(from_path) * sizeof(wchar_t)); readsize -= paddingSize;
BackupDataHeader header; s_FinishedFileSize += readsize;
BackupDataHeader enc; s_Progress = s_FinishedFileSize * 100 / s_TotalFileSize;
std::memset(&header, 0, sizeof(header)); NN_LOG( "finish = %lld, total = %lld, progress = %lld\n", s_FinishedFileSize, s_TotalFileSize, s_Progress);
std::memset(&enc, 0, sizeof(enc));
header.size = filesize;
result = swAesCtrContext.Encrypt(&enc, &header, sizeof(header));
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
context.Update(&enc, sizeof(enc));
s32 writeSize;
result = to_file.TryWrite(&writeSize, &enc, sizeof(enc), false);
if (result.IsFailure())
{
return false;
}
while (1)
{
// バッファの後半半分を暗号・復号用に使う
result = from_file.TryRead(&readsize, buf, bufSize / 2);
totalReadSize += readsize;
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
else
{
if (readsize == 0)
{
NN_LOG("Add CMAC %ls\n", from_path);
// SHA256を計算してCMACを付加する
bit8 sha256Hash[nn::crypto::Sha256Context::HASH_SIZE];
context.GetHash(sha256Hash);
bit8 cmac[nn::crypto::AES_CMAC_MAC_SIZE];
result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, nn::crypto::Sha256Context::HASH_SIZE,
common::cmacKey);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
result = to_file.TryWrite(&writesize, cmac, sizeof(cmac));
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
result = to_file.TryFlush();
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
break;
}
else
{
NN_LOG("EncryptSize = %d\n", readsize);
u8 paddingSize = 0;
AddPkcsPadding(&paddingSize, reinterpret_cast<bit8*> (buf), bufSize / 2, &readsize);
// 暗号化後SHA256を計算しつつ書き込み
result = swAesCtrContext.Encrypt(reinterpret_cast<bit8*> (buf) + bufSize / 2, buf, readsize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
context.Update(reinterpret_cast<bit8*> (buf) + bufSize / 2, readsize);
result = to_file.TryWrite(&writesize, reinterpret_cast<bit8*> (buf) + bufSize / 2, readsize,
false);
// 事前計算したファイルサイズに一致させるためパディング分減算
readsize -= paddingSize;
s_FinishedFileSize += readsize;
s_Progress = s_FinishedFileSize * 100 / s_TotalFileSize;
NN_LOG("finish = %lld, total = %lld, progress = %lld\n", s_FinishedFileSize, s_TotalFileSize, s_Progress);
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
}
}
}
to_file.Finalize();
} }
} }
to_file.Finalize();
from_file.Finalize(); from_file.Finalize();
return true; return true;
@ -312,12 +262,7 @@ bool CopyDirectory(ImportDataList* fileList, const wchar_t * from_path, const wc
std::wostringstream target_to; std::wostringstream target_to;
nn::Result result = from_dir.TryInitialize(from_path); nn::Result result = from_dir.TryInitialize(from_path);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
while (1) while (1)
{ {
@ -362,7 +307,10 @@ bool CopyDirectory(ImportDataList* fileList, const wchar_t * from_path, const wc
target_to << L"/"; target_to << L"/";
if(encode) if(encode)
{ {
AddPathNameAndUpdateContext(list, target_to.str().c_str(), -1, listContext); if(!AddPathNameAndUpdateContext(list, target_to.str().c_str(), -1, listContext))
{
return false;
}
} }
// 再帰処理 // 再帰処理
@ -373,8 +321,7 @@ bool CopyDirectory(ImportDataList* fileList, const wchar_t * from_path, const wc
} }
else else
{ {
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
return false;
} }
} }
// ファイルの場合 // ファイルの場合
@ -405,238 +352,195 @@ bool CopyDirectory(ImportDataList* fileList, const wchar_t * from_path, const wc
// 読み込み対象ファイル開く // 読み込み対象ファイル開く
result = from_file.TryInitialize(target_from.str().c_str()); result = from_file.TryInitialize(target_from.str().c_str());
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (result.IsFailure()) // 読み込み対象ファイルのサイズ取得
result = from_file.TryGetSize(&filesize);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (encode)
{ {
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); if (!AddPathNameAndUpdateContext(list, target_to.str().c_str(), filesize, listContext))
return false; {
return false;
}
}
nn::crypto::SwAesCtrContext swAesCtrContext;
swAesCtrContext.Initialize(iv, common::key, sizeof(key));
size_t totalReadSize = 0;
nn::crypto::Sha256Context context;
context.Initialize();
// ファイルサイズをヘッダに書いておく
if (encode)
{
// 書き込み対象ファイル作成
result = nn::fs::TryCreateFile(target_tmp.str().c_str(), filesize);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = to_file.TryInitialize(target_tmp.str().c_str(),
nn::fs::OPEN_MODE_READ | nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
// フルパスをハッシュに含める
context.Update(target_from.str().c_str(), target_from.str().size() * sizeof(wchar_t));
BackupDataHeader header;
BackupDataHeader enc;
std::memset(&header, 0, sizeof(header));
std::memset(&enc, 0, sizeof(enc));
header.size = filesize;
result = swAesCtrContext.Encrypt(&enc, &header, sizeof(header));
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context.Update(&enc, sizeof(enc));
s32 writeSize;
result = to_file.TryWrite(&writeSize, &enc, sizeof(enc), false);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
} }
else else
{ {
// 読み込み対象ファイルのサイズ取得 // ヘッダを読む
result = from_file.TryGetSize(&filesize); // ハッシュの計算は終わっているので復号化のみ
if (result.IsFailure()) BackupDataHeader header;
BackupDataHeader dec;
std::memset(&header, 0, sizeof(header));
std::memset(&dec, 0, sizeof(dec));
s32 readSize;
result = from_file.TryRead(&readSize, &header, sizeof(header));
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
swAesCtrContext.Decrypt(&dec, &header, sizeof(header));
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
fileSizeWithoutHeaderAndFooter = dec.size;
// 書き込み対象ファイル作成
result = nn::fs::TryCreateFile(target_tmp.str().c_str(), fileSizeWithoutHeaderAndFooter);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = to_file.TryInitialize(target_tmp.str().c_str(),
nn::fs::OPEN_MODE_READ | nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
}
while (1)
{
// バッファの後半半分を暗号・復号用に使う
result = from_file.TryRead(&readsize, buf, bufSize / 2);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
totalReadSize += readsize;
if (readsize == 0)
{ {
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); if (encode)
return false; {
NN_LOG("Add CMAC %ls\n", target_from.str().c_str());
// SHA256を計算してCMACを付加する
bit8 sha256Hash[nn::crypto::Sha256Context::HASH_SIZE];
context.GetHash(sha256Hash);
bit8 cmac[nn::crypto::AES_CMAC_MAC_SIZE];
result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, nn::crypto::Sha256Context::HASH_SIZE,
common::cmacKey);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = to_file.TryWrite(&writesize, cmac, sizeof(cmac));
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
}
result = to_file.TryFlush();
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
// 復号済みなら検証する
if (!encode)
{
if (!ConfirmFile(&from_file, &to_file, filesize, fileSizeWithoutHeaderAndFooter, buf, bufSize,
target_from.str().c_str(), target_tmp.str().c_str(), target_to.str().c_str()))
{
return false;
}
}
break;
} }
else else
{ {
if(encode)
{
AddPathNameAndUpdateContext(list, target_to.str().c_str(), filesize, listContext);
}
nn::crypto::SwAesCtrContext swAesCtrContext;
swAesCtrContext.Initialize(iv, common::key, sizeof(key));
size_t totalReadSize = 0;
nn::crypto::Sha256Context context;
context.Initialize();
// ファイルサイズをヘッダに書いておく
if (encode) if (encode)
{ {
// 書き込み対象ファイル作成 NN_LOG("EncryptSize = %d\n", readsize);
result = nn::fs::TryCreateFile(target_tmp.str().c_str(), filesize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
result = to_file.TryInitialize(target_tmp.str().c_str(),
nn::fs::OPEN_MODE_READ | nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE);
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
// フルパスをハッシュに含める u8 paddingSize = 0;
context.Update(target_from.str().c_str(), target_from.str().size() * sizeof(wchar_t)); AddPkcsPadding(&paddingSize, reinterpret_cast<bit8*>(buf), bufSize / 2, &readsize);
BackupDataHeader header; // 暗号化後SHA256を計算しつつ書き込み
BackupDataHeader enc; result = swAesCtrContext.Encrypt(reinterpret_cast<bit8*>(buf) + bufSize / 2, buf, readsize);
std::memset(&header, 0, sizeof(header)); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
std::memset(&enc, 0, sizeof(enc)); context.Update(reinterpret_cast<bit8*>(buf) + bufSize / 2, readsize);
header.size = filesize;
result = swAesCtrContext.Encrypt(&enc, &header, sizeof(header)); result = to_file.TryWrite(&writesize, reinterpret_cast<bit8*>(buf) + bufSize / 2, readsize,
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); false);
context.Update(&enc, sizeof(enc)); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
s32 writeSize;
result = to_file.TryWrite(&writeSize, &enc, sizeof(enc), false); // 事前計算したファイルサイズに一致させるためパディング分減算
if (result.IsFailure()) readsize -= paddingSize;
{
return false; s_FinishedFileSize += readsize;
} s_Progress = s_FinishedFileSize * 100 / s_TotalFileSize;
NN_LOG(
"finish = %lld, total = %lld, progress = %lld\n", s_FinishedFileSize, s_TotalFileSize, s_Progress);
} }
else else
{ {
// ヘッダを読む // ハッシュ検証は通っているので復号化しつつ書き込み
// ハッシュの計算は終わっているので復号化のみ // パディング以降は書き込まないよう書き込みサイズを変更する
BackupDataHeader header;
BackupDataHeader dec;
std::memset(&header, 0, sizeof(header));
std::memset(&dec, 0, sizeof(dec));
s32 readSize;
result = from_file.TryRead(&readSize, &header, sizeof(header));
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
swAesCtrContext.Decrypt(&dec, &header, sizeof(header));
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
fileSizeWithoutHeaderAndFooter = dec.size;
// 書き込み対象ファイル作成 NN_LOG("DecryptSize = %d\n", readsize);
result = nn::fs::TryCreateFile(target_tmp.str().c_str(), fileSizeWithoutHeaderAndFooter); result = swAesCtrContext.Decrypt(reinterpret_cast<bit8*>(buf) + bufSize / 2, buf, readsize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
result = to_file.TryInitialize(target_tmp.str().c_str(),
nn::fs::OPEN_MODE_READ | nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE); // パディングまで読んだかどうか
if (result.IsFailure()) bool readDone = false;
// パディングまで読んでいたら書き込みサイズを減らす
if (fileSizeWithoutHeaderAndFooter < totalReadSize)
{ {
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); readsize -= totalReadSize - fileSizeWithoutHeaderAndFooter;
return false; readDone = true;
}
result = to_file.TryWrite(&writesize, reinterpret_cast<bit8*>(buf) + bufSize / 2, readsize,
false);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
s_FinishedFileSize += readsize;
s_Progress = s_FinishedFileSize * 100 / s_TotalFileSize;
NN_LOG(
"finish = %lld, total = %lld, progress = %lld\n", s_FinishedFileSize, s_TotalFileSize, s_Progress);
// 読みきったので次のファイルへ
if (readDone)
{
result = to_file.TryFlush();
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (!ConfirmFile(&from_file, &to_file, filesize, fileSizeWithoutHeaderAndFooter, buf,
bufSize, target_from.str().c_str(), target_tmp.str().c_str(),
target_to.str().c_str()))
{
return false;
}
break;
} }
} }
while (1) if (result.IsFailure())
{ {
// バッファの後半半分を暗号・復号用に使う COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
result = from_file.TryRead(&readsize, buf, bufSize / 2); return false;
totalReadSize += readsize;
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
else
{
if (readsize == 0)
{
if (encode)
{
NN_LOG("Add CMAC %ls\n", target_from.str().c_str());
// SHA256を計算してCMACを付加する
bit8 sha256Hash[nn::crypto::Sha256Context::HASH_SIZE];
context.GetHash(sha256Hash);
bit8 cmac[nn::crypto::AES_CMAC_MAC_SIZE];
result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash,
nn::crypto::Sha256Context::HASH_SIZE, common::cmacKey);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
result = to_file.TryWrite(&writesize, cmac, sizeof(cmac));
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
}
result = to_file.TryFlush();
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
// 復号済みなら検証する
if (!encode)
{
if (!ConfirmFile(&from_file, &to_file, filesize, fileSizeWithoutHeaderAndFooter,
buf, bufSize, target_from.str().c_str(), target_tmp.str().c_str(),
target_to.str().c_str()))
{
return false;
}
}
break;
}
else
{
if (encode)
{
NN_LOG("EncryptSize = %d\n", readsize);
u8 paddingSize = 0;
AddPkcsPadding(&paddingSize, reinterpret_cast<bit8*>(buf), bufSize / 2, &readsize);
// 暗号化後SHA256を計算しつつ書き込み
result = swAesCtrContext.Encrypt(reinterpret_cast<bit8*> (buf) + bufSize / 2, buf,
readsize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
context.Update(reinterpret_cast<bit8*> (buf) + bufSize / 2, readsize);
result = to_file.TryWrite(&writesize, reinterpret_cast<bit8*> (buf) + bufSize / 2,
readsize, false);
// 事前計算したファイルサイズに一致させるためパディング分減算
readsize -= paddingSize;
s_FinishedFileSize += readsize;
s_Progress = s_FinishedFileSize * 100 / s_TotalFileSize;
NN_LOG("finish = %lld, total = %lld, progress = %lld\n", s_FinishedFileSize, s_TotalFileSize, s_Progress);
}
else
{
// ハッシュ検証は通っているので復号化しつつ書き込み
// パディング以降は書き込まないよう書き込みサイズを変更する
NN_LOG("DecryptSize = %d\n", readsize);
result = swAesCtrContext.Decrypt(reinterpret_cast<bit8*> (buf) + bufSize / 2, buf,
readsize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
// パディングまで読んだかどうか
bool readDone = false;
// パディングまで読んでいたら書き込みサイズを減らす
if (fileSizeWithoutHeaderAndFooter < totalReadSize)
{
readsize -= totalReadSize - fileSizeWithoutHeaderAndFooter;
readDone = true;
}
result = to_file.TryWrite(&writesize, reinterpret_cast<bit8*> (buf) + bufSize / 2,
readsize, false);
s_FinishedFileSize += readsize;
s_Progress = s_FinishedFileSize * 100 / s_TotalFileSize;
NN_LOG("finish = %lld, total = %lld, progress = %lld\n", s_FinishedFileSize, s_TotalFileSize, s_Progress);
// 読みきったので次のファイルへ
if (readDone)
{
result = to_file.TryFlush();
if (result.IsFailure())
{
return false;
}
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
if (!ConfirmFile(&from_file, &to_file, filesize,
fileSizeWithoutHeaderAndFooter, buf, bufSize,
target_from.str().c_str(), target_tmp.str().c_str(),
target_to.str().c_str()))
{
return false;
}
break;
}
}
if (result.IsFailure())
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
}
}
} }
to_file.Finalize();
} }
} }
to_file.Finalize();
from_file.Finalize(); from_file.Finalize();
} }
} }
@ -666,11 +570,7 @@ bool CalculateAndCompareCmac(nn::crypto::Sha256Context* context, bit8* sdCmac)
context->Finalize(); context->Finalize();
result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, sizeof(sha256Hash), common::cmacKey); result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, sizeof(sha256Hash), common::cmacKey);
if (result.IsFailure()) COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
{
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return false;
}
return std::memcmp(cmac, sdCmac, sizeof(cmac)) == 0; return std::memcmp(cmac, sdCmac, sizeof(cmac)) == 0;
} }
@ -727,7 +627,7 @@ bool VerifyMac(nn::fs::FileInputStream* sdFile, nn::fs::FileStream* nandFile, s6
std::memset(&enc, 0, sizeof(enc)); std::memset(&enc, 0, sizeof(enc));
header.size = nandFileSize; header.size = nandFileSize;
result = swAesCtrContext.Encrypt(&enc, &header, sizeof(header)); result = swAesCtrContext.Encrypt(&enc, &header, sizeof(header));
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context.Update(&enc, sizeof(enc)); context.Update(&enc, sizeof(enc));
bool retValue = false; bool retValue = false;
@ -736,8 +636,6 @@ bool VerifyMac(nn::fs::FileInputStream* sdFile, nn::fs::FileStream* nandFile, s6
while (1) while (1)
{ {
result = nandFile->TryRead(&readSize, buf, bufSize / 2); result = nandFile->TryRead(&readSize, buf, bufSize / 2);
totalReadSize += readSize;
if (result.IsFailure()) if (result.IsFailure())
{ {
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
@ -746,6 +644,8 @@ bool VerifyMac(nn::fs::FileInputStream* sdFile, nn::fs::FileStream* nandFile, s6
} }
else else
{ {
totalReadSize += readSize;
if (readSize == 0) if (readSize == 0)
{ {
retValue = CalculateAndCompareCmac(&context, sdCmac); retValue = CalculateAndCompareCmac(&context, sdCmac);
@ -756,7 +656,7 @@ bool VerifyMac(nn::fs::FileInputStream* sdFile, nn::fs::FileStream* nandFile, s6
u8 paddingSize = 0; u8 paddingSize = 0;
AddPkcsPadding(&paddingSize, reinterpret_cast<bit8*>(buf), bufSize / 2, &readSize); AddPkcsPadding(&paddingSize, reinterpret_cast<bit8*>(buf), bufSize / 2, &readSize);
result = swAesCtrContext.Encrypt(reinterpret_cast<bit8*>(buf) + bufSize / 2, buf, readSize); result = swAesCtrContext.Encrypt(reinterpret_cast<bit8*>(buf) + bufSize / 2, buf, readSize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context.Update(reinterpret_cast<bit8*>(buf) + bufSize / 2 , readSize); context.Update(reinterpret_cast<bit8*>(buf) + bufSize / 2 , readSize);
if (result.IsFailure()) if (result.IsFailure())
@ -786,8 +686,7 @@ bool ConfirmFile(nn::fs::FileInputStream* from_file, nn::fs::FileStream* to_file
s_FinishedFileSize -= nandFileSize; s_FinishedFileSize -= nandFileSize;
COMMON_LOGGER("**********Verification Failed %s, Delete**********\n", GetCharStr(sdPath)); COMMON_LOGGER("**********Verification Failed %s, Delete**********\n", GetCharStr(sdPath));
result = nn::fs::TryDeleteFile(tmpPath); result = nn::fs::TryDeleteFile(tmpPath);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
return false;
} }
else else
{ {
@ -797,8 +696,7 @@ bool ConfirmFile(nn::fs::FileInputStream* from_file, nn::fs::FileStream* to_file
if (result.IsFailure() && !nn::fs::ResultNotFound::Includes(result)) if (result.IsFailure() && !nn::fs::ResultNotFound::Includes(result))
{ {
COMMON_LOGGER("**********Verification Failed %s, Delete**********\n", GetCharStr(sdPath)); COMMON_LOGGER("**********Verification Failed %s, Delete**********\n", GetCharStr(sdPath));
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
return false;
} }
// 正しいファイル名にリネームする // 正しいファイル名にリネームする
@ -846,7 +744,7 @@ bool ContainsNimSaveDataDir(const wchar_t* str)
//! @param[in] str 入力文字列 //! @param[in] str 入力文字列
//! @param[in] fileSize サイズ //! @param[in] fileSize サイズ
//! @param[in] context SHA-256計算用コンテキスト //! @param[in] context SHA-256計算用コンテキスト
void AddPathNameAndUpdateContext(nn::fs::FileOutputStream* file, const wchar_t *str, s64 fileSize, bool AddPathNameAndUpdateContext(nn::fs::FileOutputStream* file, const wchar_t *str, s64 fileSize,
nn::crypto::Sha256Context* context) nn::crypto::Sha256Context* context)
{ {
nn::Result result; nn::Result result;
@ -854,30 +752,32 @@ void AddPathNameAndUpdateContext(nn::fs::FileOutputStream* file, const wchar_t *
if(ContainsNimSaveDataDir(str)) if(ContainsNimSaveDataDir(str))
{ {
return; return true;
} }
std::string output(GetCharStr(str)); std::string output(GetCharStr(str));
result = file->TryWrite(&writeSize, output.c_str(), output.size(), true); result = file->TryWrite(&writeSize, output.c_str(), output.size(), true);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context->Update(output.c_str(), output.size()); context->Update(output.c_str(), output.size());
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
char comma = ','; char comma = ',';
result = file->TryWrite(&writeSize, &comma, sizeof(comma), true); result = file->TryWrite(&writeSize, &comma, sizeof(comma), true);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context->Update(&comma, sizeof(comma)); context->Update(&comma, sizeof(comma));
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
char sizeStr[10]; char sizeStr[10];
std::memset(sizeStr, 0, sizeof(sizeStr)); std::memset(sizeStr, 0, sizeof(sizeStr));
s32 sizeStrSize = std::snprintf(sizeStr, sizeof(sizeStr), "%lld", fileSize); s32 sizeStrSize = std::snprintf(sizeStr, sizeof(sizeStr), "%lld", fileSize);
result = file->TryWrite(&writeSize, sizeStr, sizeStrSize, true); result = file->TryWrite(&writeSize, sizeStr, sizeStrSize, true);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context->Update(sizeStr, sizeStrSize); context->Update(sizeStr, sizeStrSize);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
char newLine = '\n'; char newLine = '\n';
result = file->TryWrite(&writeSize, &newLine, sizeof(newLine), true); result = file->TryWrite(&writeSize, &newLine, sizeof(newLine), true);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
context->Update(&newLine, sizeof(newLine)); context->Update(&newLine, sizeof(newLine));
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
return true;
} }
} }

2
trunk/ConsoleDataMigration/sources/common/FileTransfer.h
View File

@ -29,7 +29,7 @@ nn::Result CalculateFileNum(std::wstring currentDirectory, u32& fileNum, s64& fi
// 単一のディレクトリを作成する // 単一のディレクトリを作成する
// アーカイブはマウント済みにしておく // アーカイブはマウント済みにしておく
void ExportTwlSaveDirectory(const wchar_t* dirPath, nn::fs::FileOutputStream* list, bool ExportTwlSaveDirectory(const wchar_t* dirPath, nn::fs::FileOutputStream* list,
nn::crypto::Sha256Context* listContext); nn::crypto::Sha256Context* listContext);
// 単一のファイルをコピーする // 単一のファイルをコピーする

40
trunk/ConsoleDataMigration/sources/common/HeapManager.cpp
View File

@ -18,21 +18,47 @@
namespace common namespace common
{ {
nn::fnd::ThreadSafeExpHeap HeapManager::s_AppHeap; nn::fnd::ThreadSafeExpHeap s_AppHeap;
HeapManager::HeapManager()
HeapManager::HeapManager(size_t byteSize, s32 alignment, bit8 groupId, nn::fnd::ExpHeapBase::AllocationMode mode, bool reuse)
{ {
m_Ptr = s_AppHeap.Allocate(byteSize, alignment, groupId, mode, reuse);
} }
HeapManager::~HeapManager() HeapManager::~HeapManager()
{ {
if(m_Ptr != NULL)
{
s_AppHeap.Free(m_Ptr);
}
} }
void* HeapManager::GetAddr()
nn::fnd::ThreadSafeExpHeap* HeapManager::GetHeap()
{ {
return &s_AppHeap; return m_Ptr;
}
void InitializeHeap()
{
s_AppHeap.Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR);
}
size_t GetAllocatableSize(s32 alignment)
{
return s_AppHeap.GetAllocatableSize(alignment);
}
void* ForceAllocate(size_t byteSize, s32 alignment, bit8 groupId, nn::fnd::ExpHeapBase::AllocationMode mode, bool reuse)
{
return s_AppHeap.Allocate(byteSize, alignment, groupId, mode, reuse);
}
void ForceFree(void* ptr)
{
if(ptr != NULL)
{
s_AppHeap.Free(ptr);
}
} }
} }

19
trunk/ConsoleDataMigration/sources/common/HeapManager.h
View File

@ -17,6 +17,7 @@
#define HEAPMANAGER_H_ #define HEAPMANAGER_H_
#include <nn.h> #include <nn.h>
#include <nn/fnd.h>
namespace common namespace common
{ {
@ -24,17 +25,27 @@ namespace common
class HeapManager class HeapManager
{ {
public: public:
HeapManager(); explicit HeapManager(size_t byteSize, s32 alignment = nn::fnd::ExpHeapBase::DEFAULT_ALIGNMENT, bit8 groupId = 0,
nn::fnd::ExpHeapBase::AllocationMode mode = nn::fnd::ExpHeapBase::ALLOCATION_MODE_FIRST_FIT, bool reuse = false);
virtual ~HeapManager(); virtual ~HeapManager();
static nn::fnd::ThreadSafeExpHeap* GetHeap(); void* GetAddr();
private: private:
// デバイスメモリ管理用拡張ヒープ void* m_Ptr;
static nn::fnd::ThreadSafeExpHeap s_AppHeap;
}; };
void InitializeHeap();
size_t GetAllocatableSize(s32 alignment = nn::fnd::ExpHeapBase::DEFAULT_ALIGNMENT);
// HeapManagerを使わず確保する場合のみ
void* ForceAllocate(size_t byteSize, s32 alignment = nn::fnd::ExpHeapBase::DEFAULT_ALIGNMENT, bit8 groupId = 0,
nn::fnd::ExpHeapBase::AllocationMode mode = nn::fnd::ExpHeapBase::ALLOCATION_MODE_FIRST_FIT, bool reuse = false);
// HeapManagerを使わず解放する場合のみ
void ForceFree(void* ptr);
} // namespace common } // namespace common
#endif /* HEAPMANAGER_H_ */ #endif /* HEAPMANAGER_H_ */

224
trunk/ConsoleDataMigration/sources/common/PlayHistoryManager.cpp
View File

@ -1,224 +0,0 @@
/*---------------------------------------------------------------------------*
Project: Horizon
File: PlayHistoryManager.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 <nn/pl.h>
#include <nn/pl/CTR/pl_PlayHistoryApiSysmenu.h>
#include "PlayHistoryManager.h"
#include "HeapManager.h"
#include "SdMountManager.h"
#include "SdReaderWriter.h"
#include "CommonLogger.h"
#include "FileName.h"
#include "ProgramId.h"
namespace common
{
PlayHistoryManager::PlayHistoryManager()
{
}
PlayHistoryManager::~PlayHistoryManager()
{
}
void PlayHistoryManager::Export()
{
nn::Result result;
SdMountManager::Mount();
SdReaderWriter sd;
size_t historyNum = nn::pl::CTR::GetPlayHistoryLength();
if ( historyNum == 0)
{
NN_LOG("No Play Event\n");
return;
}
// SDに書き込む
result = sd.WriteBufWithCmac(common::PLAYHISTORY_COUNT_PATHNAME, reinterpret_cast<void*>(&historyNum),
sizeof(historyNum));
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
nn::pl::CTR::PlayEvent* pEvent;
pEvent = reinterpret_cast<nn::pl::CTR::PlayEvent*> (HeapManager::GetHeap()->Allocate(
sizeof(nn::pl::CTR::PlayEvent) * historyNum));
if ( pEvent == NULL )
{
NN_LOG("Failed to Allocate Heap\n");
return;
}
// 一番古いデータから素直に全部読み込む
nn::pl::CTR::GetPlayHistory(pEvent, 0, historyNum);
// SDに書き込む
result = sd.WriteBufWithCmac(common::PLAYHISTORY_PATHNAME, reinterpret_cast<void*>(pEvent),
sizeof(nn::pl::CTR::PlayEvent) * historyNum);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
HeapManager::GetHeap()->Free(pEvent);
SdMountManager::Unmount();
}
nn::Result PlayHistoryManager::GetPlayHistoryNums(size_t* nums)
{
nn::Result result = nn::ResultSuccess();
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize();
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize);
if (buf != NULL)
{
common::SdReaderWriter sdReader;
size_t readSize;
result = sdReader.ReadBufWithCmac(common::PLAYHISTORY_COUNT_PATHNAME, buf, bufSize, &readSize);
if (result.IsSuccess())
{
*nums = *reinterpret_cast<size_t*> (buf);
}
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
HeapManager::GetHeap()->Free(buf);
}
return result;
}
nn::Result PlayHistoryManager::Import()
{
nn::Result result = nn::ResultSuccess();
SdMountManager::Mount();
SdReaderWriter sd;
SdMountManager::Mount();
// プレイ履歴の件数を取得する
size_t historyNum = 0;
GetPlayHistoryNums(&historyNum);
if(historyNum == 0)
{
NN_LOG("No PlayHistory found\n");
return nn::Result(nn::Result::LEVEL_PERMANENT, nn::Result::SUMMARY_NOT_FOUND, nn::Result::MODULE_COMMON,
nn::Result::DESCRIPTION_NOT_FOUND);
}
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize();
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize);
if (buf != NULL)
{
common::SdReaderWriter sdReader;
size_t readSize;
result = sdReader.ReadBufWithCmac(common::PLAYHISTORY_PATHNAME, buf, bufSize, &readSize);
if(result.IsSuccess())
{
nn::pl::CTR::PlayEvent* pEvent = reinterpret_cast<nn::pl::CTR::PlayEvent*>(buf);
NN_LOG("history num = %d\n", historyNum);
// プレイ履歴を無効化する
nn::pl::CTR::ClearPlayHistory();
// データ移行ツールを無視して書き込む
for(u32 i = 0; i < historyNum; i++)
{
COMMON_LOGGER("Importing PlayHistory %d/%d", i, historyNum);
if ((pEvent[i].GetProgramId() & WITHOUT_VALIATION_MASK) != CONSOLE_BACKUP_PROGRAM_ID
&& (pEvent[i].GetProgramId() & WITHOUT_VALIATION_MASK) != CONSOLE_RESTORE_PROGRAM_ID)
{
NN_LOG("%05d 0x%16llx : %X : %d\n", i, pEvent[i].GetProgramId(), pEvent[i].GetEventType(),
pEvent[i].minutes);
nn::pl::CTR::NotifyPlayEvent(pEvent[i].GetEventType(), pEvent[i].GetProgramId(),
pEvent[i].GetEventTime());
}
else
{
NN_LOG("Skipped\n");
}
}
}
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
common::HeapManager::GetHeap()->Free(buf);
}
else
{
NN_LOG("Failed Allocate Heap!! %s, %d", __FILE__, __LINE__);
return result;
}
SdMountManager::Unmount();
return result;
}
void PlayHistoryManager::Dump()
{
nn::Result result;
s32 playEventLength = nn::pl::CTR::GetPlayHistoryLength();
if ( playEventLength == 0 )
{
NN_LOG("No Play Event\n");
return;
}
nn::pl::CTR::PlayEvent* playEvent = reinterpret_cast<nn::pl::CTR::PlayEvent*> (HeapManager::GetHeap()->Allocate(
sizeof(nn::pl::CTR::PlayEvent) * playEventLength));
if ( playEvent == NULL )
{
NN_LOG("Failed to Allocate Heap\n");
return;
}
// 一番古いデータから素直に全部読み込む
(void)nn::pl::CTR::GetPlayHistory(playEvent, 0, playEventLength);
// 取得したデータを順番にすべて表示していく
s32 restPlayEventLength = playEventLength;
s32 displayCount = 0;
nn::pl::CTR::PlayEvent* pEvent;
while ( restPlayEventLength > 0 )
{
// 一気に表示できるところまで表示する
int line;
for ( line = 0; line < 24; line++ )
{
pEvent = &playEvent[displayCount];
NN_LOG("0x%16llx : %X : %d\n", pEvent->GetProgramId(), pEvent->eventType, pEvent->minutes);
restPlayEventLength--;
displayCount++;
if(restPlayEventLength <= 0)
{
break;
}
}
}
NN_UNUSED_VAR(pEvent);
HeapManager::GetHeap()->Free(playEvent);
return;
}
}

45
trunk/ConsoleDataMigration/sources/common/PlayHistoryManager.h
View File

@ -1,45 +0,0 @@
/*---------------------------------------------------------------------------*
Project: Horizon
File: PlayHistoryManager.h
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$
*---------------------------------------------------------------------------*/
#ifndef PLAYHISTORYMANAGER_H_
#define PLAYHISTORYMANAGER_H_
namespace common
{
//! @brief データ移行ツールの履歴を消しながらプレイ履歴を移行するためのクラスです。
class PlayHistoryManager
{
public:
PlayHistoryManager();
virtual ~PlayHistoryManager();
//! @brief SDカードに出力します。
void Export();
//! @brief SDカードからプレイ履歴に書き込みます
nn::Result Import();
//! @brief デバッグ用。プレイ履歴をデバッグ出力します。
void Dump();
private:
nn::Result GetPlayHistoryNums(size_t* nums);
};
}
#endif /* PLAYHISTORYMANAGER_H_ */

24
trunk/ConsoleDataMigration/sources/common/ResFont.cpp
View File

@ -63,7 +63,7 @@ InitShaders(nn::font::RectDrawer* pDrawer)
const u32 fileSize = (u32)shaderReader.GetSize(); const u32 fileSize = (u32)shaderReader.GetSize();
void* shaderBinary = HeapManager::GetHeap()->Allocate(fileSize); void* shaderBinary = ForceAllocate(fileSize);
NN_NULL_ASSERT(shaderBinary); NN_NULL_ASSERT(shaderBinary);
#ifndef NN_BUILD_RELEASE #ifndef NN_BUILD_RELEASE
@ -74,12 +74,10 @@ InitShaders(nn::font::RectDrawer* pDrawer)
const u32 vtxBufCmdBufSize = const u32 vtxBufCmdBufSize =
nn::font::RectDrawer::GetVertexBufferCommandBufferSize(shaderBinary, fileSize); nn::font::RectDrawer::GetVertexBufferCommandBufferSize(shaderBinary, fileSize);
void *const vtxBufCmdBuf = HeapManager::GetHeap()->Allocate(vtxBufCmdBufSize); void *const vtxBufCmdBuf = ForceAllocate(vtxBufCmdBufSize);
NN_NULL_ASSERT(vtxBufCmdBuf); NN_NULL_ASSERT(vtxBufCmdBuf);
pDrawer->Initialize(vtxBufCmdBuf, shaderBinary, fileSize); pDrawer->Initialize(vtxBufCmdBuf, shaderBinary, fileSize);
HeapManager::GetHeap()->Free(shaderBinary);
return vtxBufCmdBuf; return vtxBufCmdBuf;
} }
@ -180,7 +178,7 @@ InitFont(
return false; return false;
} }
void* buffer = HeapManager::GetHeap()->Allocate(fileSize, nn::font::GlyphDataAlignment); void* buffer = common::ForceAllocate(fileSize, nn::font::GlyphDataAlignment);
if (buffer == NULL) if (buffer == NULL)
{ {
return false; return false;
@ -189,7 +187,7 @@ InitFont(
s32 readSize = fontReader.Read(buffer, fileSize); s32 readSize = fontReader.Read(buffer, fileSize);
if (readSize != fileSize) if (readSize != fileSize)
{ {
HeapManager::GetHeap()->Free(buffer); common::ForceFree(buffer);
return false; return false;
} }
@ -200,12 +198,12 @@ InitFont(
//--- 既にリソースをセット済みであるか，ロード済みであるか、リソースが不正な場合に失敗します。 //--- 既にリソースをセット済みであるか，ロード済みであるか、リソースが不正な場合に失敗します。
if (! bSuccess) if (! bSuccess)
{ {
HeapManager::GetHeap()->Free(buffer); common::ForceFree(buffer);
} }
// 描画用バッファを設定します。 // 描画用バッファを設定します。
const u32 drawBufferSize = nn::font::ResFont::GetDrawBufferSize(buffer); const u32 drawBufferSize = nn::font::ResFont::GetDrawBufferSize(buffer);
void* drawBuffer = HeapManager::GetHeap()->Allocate(drawBufferSize, 4); void* drawBuffer = common::ForceAllocate(drawBufferSize, 4);
NN_NULL_ASSERT(drawBuffer); NN_NULL_ASSERT(drawBuffer);
pFont->SetDrawBuffer(drawBuffer); pFont->SetDrawBuffer(drawBuffer);
@ -226,7 +224,7 @@ CleanupFont(nn::font::ResFont* pFont)
void *const drawBuffer = pFont->SetDrawBuffer(NULL); void *const drawBuffer = pFont->SetDrawBuffer(NULL);
if (drawBuffer != NULL) if (drawBuffer != NULL)
{ {
HeapManager::GetHeap()->Free(drawBuffer); ForceFree(drawBuffer);
} }
// フォントがセットされているなら SetResource 時に渡したリソースへの // フォントがセットされているなら SetResource 時に渡したリソースへの
@ -234,7 +232,7 @@ CleanupFont(nn::font::ResFont* pFont)
void *const resource = pFont->RemoveResource(); void *const resource = pFont->RemoveResource();
if (resource != NULL) if (resource != NULL)
{ {
HeapManager::GetHeap()->Free(resource); ForceFree(resource);
} }
// RemoveResource 後は再度 SetResource するまでフォントとして使用できません。 // RemoveResource 後は再度 SetResource するまでフォントとして使用できません。
@ -251,7 +249,7 @@ nn::font::DispStringBuffer*
AllocDispStringBuffer(s32 charMax) AllocDispStringBuffer(s32 charMax)
{ {
const u32 DrawBufferSize = nn::font::CharWriter::GetDispStringBufferSize(charMax); const u32 DrawBufferSize = nn::font::CharWriter::GetDispStringBufferSize(charMax);
void *const bufMem = HeapManager::GetHeap()->Allocate(DrawBufferSize); void *const bufMem = ForceAllocate(DrawBufferSize);
NN_NULL_ASSERT(bufMem); NN_NULL_ASSERT(bufMem);
return nn::font::CharWriter::InitDispStringBuffer(bufMem, charMax); return nn::font::CharWriter::InitDispStringBuffer(bufMem, charMax);
@ -400,13 +398,13 @@ void FinalizeResFont()
s_Drawer.Finalize(); s_Drawer.Finalize();
// 描画リソースの破棄 // 描画リソースの破棄
HeapManager::GetHeap()->Free(s_DrawerBuf); ForceFree(s_DrawerBuf);
// フォントの破棄 // フォントの破棄
CleanupFont(&s_Font); CleanupFont(&s_Font);
// 描画文字列用バッファの解放 // 描画文字列用バッファの解放
HeapManager::GetHeap()->Free(s_pDrawStringBuf0); ForceFree(s_pDrawStringBuf0);
} }
nn::font::TextWriter* GetTextWriter() nn::font::TextWriter* GetTextWriter()

15
trunk/ConsoleDataMigration/sources/common/SdReaderWriter.cpp
View File

@ -123,19 +123,19 @@ nn::Result SdReaderWriter::WriteBufWithCmac(const wchar_t* path, void* buf, size
bit8 cmac[nn::crypto::AES_CMAC_MAC_SIZE]; bit8 cmac[nn::crypto::AES_CMAC_MAC_SIZE];
result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, nn::crypto::Sha256Context::HASH_SIZE, common::cmacKey); result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, nn::crypto::Sha256Context::HASH_SIZE, common::cmacKey);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
s32 writeSize; s32 writeSize;
result = file.TryWrite(&writeSize, cmac, sizeof(cmac), false); result = file.TryWrite(&writeSize, cmac, sizeof(cmac), false);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
result = file.TryFlush(); result = file.TryFlush();
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
file.Finalize(); file.Finalize();
result = Finalize(); result = Finalize();
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
return result; return result;
@ -231,7 +231,7 @@ nn::Result SdReaderWriter::ReadBufWithCmac(const wchar_t* path, void* buf, size_
return result; return result;
} }
void SdReaderWriter::CreateDirectory(const wchar_t* path) nn::Result SdReaderWriter::CreateDirectory(const wchar_t* path)
{ {
nn::Result result; nn::Result result;
@ -242,11 +242,12 @@ void SdReaderWriter::CreateDirectory(const wchar_t* path)
NN_LOG("Create Directory %ls\n", path); NN_LOG("Create Directory %ls\n", path);
result = nn::fs::TryCreateDirectory(path); result = nn::fs::TryCreateDirectory(path);
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
result = Finalize(); result = Finalize();
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
return nn::ResultSuccess();
} }
} }

2
trunk/ConsoleDataMigration/sources/common/SdReaderWriter.h
View File

@ -42,7 +42,7 @@ public :
nn::Result ReadBufWithCmac(const wchar_t* path, void* buf, size_t size, size_t* totalSize); nn::Result ReadBufWithCmac(const wchar_t* path, void* buf, size_t size, size_t* totalSize);
//! @brief 渡されたディレクトリ名のディレクトリを作成します //! @brief 渡されたディレクトリ名のディレクトリを作成します
void CreateDirectory(const wchar_t* path); nn::Result CreateDirectory(const wchar_t* path);
private: private:
//! @brief 渡されたバッファからサイズ分指定されたパス名で書きこみます //! @brief 渡されたバッファからサイズ分指定されたパス名で書きこみます

2
trunk/ConsoleDataMigration/sources/common/SimplePlayer.cpp
View File

@ -76,7 +76,7 @@ namespace
if (::std::strcmp(::std::strrchr(apFileNames[i], '.'), ".wav") == false) if (::std::strcmp(::std::strrchr(apFileNames[i], '.'), ".wav") == false)
{ {
// 連続メモリ領域の取得、確認 // 連続メモリ領域の取得、確認
apMemory[i] = reinterpret_cast<u8*>(HeapManager::GetHeap()->Allocate(GetWaveLength(fileReader), 32)); apMemory[i] = reinterpret_cast<u8*>(ForceAllocate(GetWaveLength(fileReader), 32));
if (apMemory[i] == NULL) if (apMemory[i] == NULL)
{ {
NN_LOG("Failed to allocate continuous memory\n"); NN_LOG("Failed to allocate continuous memory\n");

2
trunk/ConsoleDataMigration/sources/common/Util.cpp
View File

@ -70,7 +70,7 @@ void Util::Initialize()
s64 fileSize = fis.GetSize(); s64 fileSize = fis.GetSize();
s32 ret; s32 ret;
void* addr = NULL; void* addr = NULL;
addr = common::HeapManager::GetHeap()->Allocate(fileSize); addr = ForceAllocate(fileSize);
if (addr != NULL) if (addr != NULL)
{ {
mp_Ivs = addr; mp_Ivs = addr;

8
trunk/ConsoleDataMigration/sources/common/VersionDetect.cpp
View File

@ -45,7 +45,8 @@ void GetCupVersion(nn::pl::CTR::CardUpdateVersion* cup, nn::cfg::CTR::CfgRegionC
NN_LOG("version.bin size = %lld\n", fileSize); NN_LOG("version.bin size = %lld\n", fileSize);
s32 ret; s32 ret;
void* addr = NULL; void* addr = NULL;
addr = common::HeapManager::GetHeap()->Allocate(fileSize); common::HeapManager heap(fileSize);
addr = heap.GetAddr();
if (addr != NULL) if (addr != NULL)
{ {
result = fis.TryRead(&ret, addr, fileSize); result = fis.TryRead(&ret, addr, fileSize);
@ -56,7 +57,6 @@ void GetCupVersion(nn::pl::CTR::CardUpdateVersion* cup, nn::cfg::CTR::CfgRegionC
std::memcpy(cup, ver_buf, sizeof(nn::pl::CTR::CardUpdateVersion)); std::memcpy(cup, ver_buf, sizeof(nn::pl::CTR::CardUpdateVersion));
} }
common::HeapManager::GetHeap()->Free(addr);
} }
} }
fis.Finalize(); fis.Finalize();
@ -88,7 +88,8 @@ void GetNupVersion(nn::pl::CTR::NetworkUpdateVersion* nup, nn::cfg::CTR::CfgRegi
NN_LOG("version.bin size = %lld\n", fileSize); NN_LOG("version.bin size = %lld\n", fileSize);
s32 ret; s32 ret;
void* addr = NULL; void* addr = NULL;
addr = common::HeapManager::GetHeap()->Allocate(fileSize); common::HeapManager heap(fileSize);
addr = heap.GetAddr();
if (addr != NULL) if (addr != NULL)
{ {
result = fis.TryRead(&ret, addr, fileSize); result = fis.TryRead(&ret, addr, fileSize);
@ -100,7 +101,6 @@ void GetNupVersion(nn::pl::CTR::NetworkUpdateVersion* nup, nn::cfg::CTR::CfgRegi
std::memcpy(nup, ver_buf, sizeof(nn::pl::CTR::NetworkUpdateVersion)); std::memcpy(nup, ver_buf, sizeof(nn::pl::CTR::NetworkUpdateVersion));
} }
common::HeapManager::GetHeap()->Free(addr);
} }
} }

8
trunk/ConsoleDataMigration/sources/common/common_Types.h
View File

@ -81,6 +81,10 @@ const nn::ProgramId cCupVerId[] =
nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_JP, nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_JP,
nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_US, nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_US,
nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_EU, nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_EU,
nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_EU,
nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_CN,
nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_KR,
nn::pl::CTR::SHAREDDATA_TITLEID_CUP_VERSION_TW,
}; };
const nn::ProgramId cNupVerId[] = const nn::ProgramId cNupVerId[] =
@ -88,6 +92,10 @@ const nn::ProgramId cNupVerId[] =
nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_JP, nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_JP,
nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_US, nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_US,
nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_EU, nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_EU,
nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_EU,
nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_CN,
nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_KR,
nn::pl::CTR::SHAREDDATA_TITLEID_NUP_VERSION_TW,
}; };
// SDに出力するデータのヘッダ // SDに出力するデータのヘッダ

1
trunk/ConsoleDataMigration/sources/tools/ExportedDataVerifier/OMakefile
View File

@ -37,7 +37,6 @@ SOURCES[] =
../../common/CommonLogger.cpp ../../common/CommonLogger.cpp
../../common/SdMountManager.cpp ../../common/SdMountManager.cpp
../../common/configLoader.cpp ../../common/configLoader.cpp
../../common/PlayHistoryManager.cpp
../../common/VersionDetect.cpp ../../common/VersionDetect.cpp
CTR_BANNER_SPEC = $(TARGET_PROGRAM).bsf CTR_BANNER_SPEC = $(TARGET_PROGRAM).bsf

13
trunk/ConsoleDataMigration/sources/tools/ExportedDataVerifier/main.cpp
View File

@ -55,7 +55,6 @@
#include "CommonLogger.h" #include "CommonLogger.h"
#include "SDMountManager.h" #include "SDMountManager.h"
#include "HeapManager.h" #include "HeapManager.h"
#include "PlayHistoryManager.h"
#include "common_Types.h" #include "common_Types.h"
#include "VersionDetect.h" #include "VersionDetect.h"
#include "Util.h" #include "Util.h"
@ -363,9 +362,10 @@ void VerifyThreadFunc()
result = common::SdMountManager::Mount(); result = common::SdMountManager::Mount();
size_t bufSize = common::HeapManager::GetHeap()->GetAllocatableSize(); size_t bufSize = common::GetAllocatableSize();
void* buf = common::HeapManager::GetHeap()->Allocate(bufSize, AES_BLOCK_SIZE); common::HeapManager heap(bufSize, AES_BLOCK_SIZE);
void* buf = heap.GetAddr();
if (buf != NULL) if (buf != NULL)
{ {
u32 i = 0; u32 i = 0;
@ -398,8 +398,6 @@ void VerifyThreadFunc()
buf, bufSize); buf, bufSize);
} }
nn::fs::Unmount(common::NAND_ARCHIVE_NAME); nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
common::HeapManager::GetHeap()->Free(buf);
} }
common::SdMountManager::Unmount(); common::SdMountManager::Unmount();
@ -428,10 +426,11 @@ extern "C" void nnMain(void)
NN_UTIL_PANIC_IF_FAILED(result); NN_UTIL_PANIC_IF_FAILED(result);
// ヒープの確保 // ヒープの確保
common::HeapManager::GetHeap()->Initialize(nn::os::GetDeviceMemoryAddress(), nn::os::GetDeviceMemorySize(), nn::os::ALLOCATE_OPTION_LINEAR); common::InitializeHeap();
// RenderSystem の準備 // RenderSystem の準備
uptr heapForGx = reinterpret_cast<uptr>(common::HeapManager::GetHeap()->Allocate(s_GxHeapSize)); common::HeapManager gxHeap(s_GxHeapSize);
uptr heapForGx = reinterpret_cast<uptr>(gxHeap.GetAddr());
demo::RenderSystemDrawing s_RenderSystem; demo::RenderSystemDrawing s_RenderSystem;
s_RenderSystem.Initialize(heapForGx, s_GxHeapSize); s_RenderSystem.Initialize(heapForGx, s_GxHeapSize);