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

trunk r375-378をマージ

Browse Source 
git-svn-id: file:///Volumes/Transfer/gigaleak_20231201/2020-05-23%20-%20ctr.7z%20+%20svn_v1.068.zip/ctr/svn/ctr_Repair@380 385bec56-5757-e545-9c3a-d8741f4650f1
This commit is contained in:
N2614 2011-07-13 04:42:20 +00:00
parent c3260682e7
commit 48de61eb1f
7 changed files with 124 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
branches/work/RW_Aging/sources/ConsoleBackup/Exporter.cpp
View File

@ -53,7 +53,6 @@ namespace ConsoleBackup
namespace namespace
{ {
common::SdReaderWriter s_SdWriter;
common::NtrNorData s_NtrNorData; common::NtrNorData s_NtrNorData;
common::CfgCountryLanguage s_CountryLanguage; common::CfgCountryLanguage s_CountryLanguage;
@ -171,7 +170,8 @@ nn::Result WriteTwlTitleList(std::vector<std::wstring>& programIdList)
writeSize += it->size() + sizeof('\n'); writeSize += it->size() + sizeof('\n');
} }
return s_SdWriter.WriteBufWithCmac(common::TWL_TITLELIST_PATHNAME, titleListBuf, writeSize); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::TWL_TITLELIST_PATHNAME, titleListBuf, writeSize);
} }
else else
{ {
@ -188,7 +188,8 @@ nn::Result WriteRegionData()
nn::cfg::CTR::CfgRegionCode region; nn::cfg::CTR::CfgRegionCode region;
region = nn::cfg::CTR::GetRegion(); region = nn::cfg::CTR::GetRegion();
return s_SdWriter.WriteBufWithCmac(common::REGION_DATA_PATHNAME, &region, sizeof(nn::cfg::CTR::CfgRegionCode)); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::REGION_DATA_PATHNAME, &region, sizeof(nn::cfg::CTR::CfgRegionCode));
} }
nn::Result WriteCountryLanguageData() nn::Result WriteCountryLanguageData()
@ -206,7 +207,8 @@ nn::Result WriteCountryLanguageData()
// 言語設定 // 言語設定
s_CountryLanguage.language = nn::cfg::CTR::GetLanguage(); s_CountryLanguage.language = nn::cfg::CTR::GetLanguage();
return s_SdWriter.WriteBufWithCmac(common::COUNTRY_SETTING_PATHNAME, &s_CountryLanguage, sizeof(s_CountryLanguage)); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::COUNTRY_SETTING_PATHNAME, &s_CountryLanguage, sizeof(s_CountryLanguage));
} }
return nn::ResultSuccess(); return nn::ResultSuccess();
@ -234,7 +236,8 @@ nn::Result WriteNorData()
result = nn::cfg::nor::CTR::ReadNtrWifiSetting(0, s_NtrNorData.NtrWiFiSetting, common::NTR_WIFI_SETTING_SIZE); result = nn::cfg::nor::CTR::ReadNtrWifiSetting(0, s_NtrNorData.NtrWiFiSetting, common::NTR_WIFI_SETTING_SIZE);
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
return s_SdWriter.WriteBufWithCmac(common::NOR_PATHNAME, &s_NtrNorData, sizeof(common::NtrNorData)); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::NOR_PATHNAME, &s_NtrNorData, sizeof(common::NtrNorData));
} }
nn::Result WriteSerialNumber(common::HardwareStateManager& manager) nn::Result WriteSerialNumber(common::HardwareStateManager& manager)
@ -245,7 +248,8 @@ nn::Result WriteSerialNumber(common::HardwareStateManager& manager)
size_t size; size_t size;
manager.GetSerialNumber(&serial, &size); manager.GetSerialNumber(&serial, &size);
return s_SdWriter.WriteBufWithCmac(common::SERIAL_PATHNAME, serial, size); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::SERIAL_PATHNAME, serial, size);
} }
nn::Result WriteDeviceId(common::HardwareStateManager& manager) nn::Result WriteDeviceId(common::HardwareStateManager& manager)
@ -254,7 +258,8 @@ nn::Result WriteDeviceId(common::HardwareStateManager& manager)
bit32 deviceId = manager.GetDeviceId(); bit32 deviceId = manager.GetDeviceId();
return s_SdWriter.WriteBufWithCmac(common::DEVICE_ID_PATHNAME, &deviceId, sizeof(deviceId)); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::DEVICE_ID_PATHNAME, &deviceId, sizeof(deviceId));
} }
nn::Result WriteIvs(common::HardwareStateManager& manager) nn::Result WriteIvs(common::HardwareStateManager& manager)
@ -279,7 +284,8 @@ nn::Result WriteIvs(common::HardwareStateManager& manager)
swAesCtrContest.Initialize(common::iv, common::key, sizeof(common::key)); swAesCtrContest.Initialize(common::iv, common::key, sizeof(common::key));
swAesCtrContest.Encrypt(enc, ivs, size); swAesCtrContest.Encrypt(enc, ivs, size);
return s_SdWriter.WriteBufWithCmac(common::IVS_PATHNAME, enc, size); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::IVS_PATHNAME, enc, size);
} }
else else
{ {
@ -292,7 +298,8 @@ void CreateTwlDirectory(enum common::TWL_PATH_INDEX path)
{ {
NN_ASSERT(path < common::TWL_PATHNAME_MAX); NN_ASSERT(path < common::TWL_PATHNAME_MAX);
s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + common::SdReaderWriter sdWriter;
sdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) +
std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str()); std::wstring(common::SD_TWL_ROOTNAME_TABLE[path])).c_str());
} }
@ -366,7 +373,8 @@ void AddCurrentDirectory(std::vector<common::SavePathInfo>* list, std::wstring c
list->push_back(pathInfo); list->push_back(pathInfo);
} }
// TWLセーブデータが存在するディレクトリの一覧をlistに追加する
// return: dataディレクトリが存在するかどうか
bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vector<common::SavePathInfo>* list, bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vector<common::SavePathInfo>* list,
std::vector<std::wstring>* programIdList) std::vector<std::wstring>* programIdList)
{ {
@ -375,6 +383,9 @@ bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vec
nn::Result result; nn::Result result;
std::vector<nn::fs::DirectoryEntry> entryList; //カレントディレクトリのエントリ一覧を格納 std::vector<nn::fs::DirectoryEntry> entryList; //カレントディレクトリのエントリ一覧を格納
std::vector<nn::fs::DirectoryEntry>::iterator entryIndex; std::vector<nn::fs::DirectoryEntry>::iterator entryIndex;
// level 0 1 2
// twln:/title/00030005/484e4441/data/
const u8 TWL_SAVEDATA_DIRECTORY_LEVEL = 2; // data ディレクトリまでの階層 const u8 TWL_SAVEDATA_DIRECTORY_LEVEL = 2; // data ディレクトリまでの階層
const wchar_t* const TWL_SAVEDATA_DIRECTORY_NAME = L"data"; const wchar_t* const TWL_SAVEDATA_DIRECTORY_NAME = L"data";
@ -392,7 +403,7 @@ bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vec
{ {
dir.Finalize(); dir.Finalize();
bool retValue = false; bool hasDataDirectory = false;
for (entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++) for (entryIndex = entryList.begin(); entryIndex != entryList.end(); entryIndex++)
{ {
// レベル2未満のディレクトリなら再帰的に開く // レベル2未満のディレクトリなら再帰的に開く
@ -400,18 +411,17 @@ bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vec
{ {
if (entryIndex->attributes.isDirectory) if (entryIndex->attributes.isDirectory)
{ {
if (ListTwlSaveDataDirectory( if (!ListTwlSaveDataDirectory(
currentDirectory + std::wstring(L"/") + std::wstring(entryIndex->entryName), level + 1, currentDirectory + std::wstring(L"/") + std::wstring(entryIndex->entryName), level + 1,
list, programIdList)) list, programIdList))
{ {
NN_LOG("%ls/%ls has data directory.\n", currentDirectory.c_str(), entryIndex->entryName); hasDataDirectory |= false;
retValue = true;
AddCurrentDirectory(list, currentDirectory, entryIndex->entryName);
} }
else else
{ {
return false; NN_LOG("%ls/%ls has data directory.\n", currentDirectory.c_str(), entryIndex->entryName);
AddCurrentDirectory(list, currentDirectory, entryIndex->entryName);
hasDataDirectory |= true;
} }
} }
} }
@ -421,15 +431,16 @@ bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vec
if (std::wcscmp(entryIndex->entryName, TWL_SAVEDATA_DIRECTORY_NAME) == 0) if (std::wcscmp(entryIndex->entryName, TWL_SAVEDATA_DIRECTORY_NAME) == 0)
{ {
// ファイル一覧を取得する // ファイル一覧を取得する
retValue = true;
if (!ListTwlSaveData( if (!ListTwlSaveData(
currentDirectory + std::wstring(L"/") + std::wstring(entryIndex->entryName), list)) currentDirectory + std::wstring(L"/") + std::wstring(entryIndex->entryName), list))
{ {
return false; hasDataDirectory |= false;
} }
NN_LOG("%ls/%ls has data directory.\n", currentDirectory.c_str(), entryIndex->entryName);
AddCurrentDirectory(list, currentDirectory, entryIndex->entryName); AddCurrentDirectory(list, currentDirectory, entryIndex->entryName);
AddCurrentProgramIdPath(programIdList, currentDirectory); AddCurrentProgramIdPath(programIdList, currentDirectory);
hasDataDirectory |= true;
} }
} }
else else
@ -438,12 +449,7 @@ bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vec
} }
} }
if (level != 0) return hasDataDirectory;
{
return retValue;
}
break;
} }
else else
{ {
@ -451,8 +457,6 @@ bool ListTwlSaveDataDirectory(std::wstring currentDirectory, u32 level, std::vec
entryList.push_back(entry); entryList.push_back(entry);
} }
} }
return true;
} }
@ -570,18 +574,17 @@ void WriteTwlSaveData()
COMMON_LOGGER("Export Twl Save Data.\n"); COMMON_LOGGER("Export Twl Save Data.\n");
// ディレクトリ作成 // ディレクトリ作成
result = s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + common::SdReaderWriter sdWriter;
result = 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); 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_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsExportSucceeded); 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); if(!ListTwlSaveDataDirectory(std::wstring(common::NAND_TWL_DATA_ROOT_PATHNAME_WITHOUT_SLASH), 0, &fileList, & programIdList))
NN_LOG("No Twl Savedata\n");
if(fileList.size() == 0)
{ {
NN_LOG("No Twl Savedata\n");
s_IsExportSucceeded = true; s_IsExportSucceeded = true;
return; return;
} }
@ -724,7 +727,8 @@ nn::Result WriteMcuRtcData(common::HardwareStateManager& manager)
{ {
NN_LOG("RTC = 20%02d/%02d/%02d %02d:%02d:%02d\n", rtc.m_Year, rtc.m_Month, rtc.m_Day, rtc.m_Hour, rtc.m_Minute, rtc.m_Second); NN_LOG("RTC = 20%02d/%02d/%02d %02d:%02d:%02d\n", rtc.m_Year, rtc.m_Month, rtc.m_Day, rtc.m_Hour, rtc.m_Minute, rtc.m_Second);
return s_SdWriter.WriteBufWithCmac(common::MCU_RTC_PATHNAME, &rtc, sizeof(rtc)); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::MCU_RTC_PATHNAME, &rtc, sizeof(rtc));
} }
nn::os::Thread::Sleep( nn::os::Thread::Sleep(
nn::fnd::TimeSpan::FromMilliSeconds( nn::fnd::TimeSpan::FromMilliSeconds(
@ -824,7 +828,8 @@ nn::Result WriteSaveData(::std::string& sysSaveRoot)
// セーブデータディレクトリ以下のデータをSDカードにコピー // セーブデータディレクトリ以下のデータをSDカードにコピー
// コピー用ディレクトリ作成 // コピー用ディレクトリ作成
result = s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring( common::SdReaderWriter sdWriter;
result = sdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(
common::SD_SAVEDATA_ROOT_NAME)).c_str()); common::SD_SAVEDATA_ROOT_NAME)).c_str());
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result); COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
@ -849,7 +854,8 @@ nn::Result WriteVersionData(common::HardwareStateManager& manager)
common::VerDef versionData; common::VerDef versionData;
manager.GetVersionData(&versionData); manager.GetVersionData(&versionData);
return s_SdWriter.WriteBufWithCmac(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef)); common::SdReaderWriter sdWriter;
return sdWriter.WriteBufWithCmac(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef));
} }
bool DeleteNimSaveData() bool DeleteNimSaveData()

180
branches/work/RW_Aging/sources/ConsoleRestore/Controller.cpp
View File

@ -135,7 +135,6 @@ typedef enum RestoreState
RESTORE_IN_PROGRESS, // 書き込み中 RESTORE_IN_PROGRESS, // 書き込み中
POST_RESTORE, // 書き込み後の処理 POST_RESTORE, // 書き込み後の処理
RESTORE_DONE, // 書き込み完了 RESTORE_DONE, // 書き込み完了
RESTORE_TEST, // 書き込み後のチェック
REBOOTING, // 再起動を行う REBOOTING, // 再起動を行う
ERASE, // 削除処理を行う ERASE, // 削除処理を行う
RESTORE_CAL, // cfgの一部をcal値で上書きする RESTORE_CAL, // cfgの一部をcal値で上書きする
@ -789,14 +788,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
// 状態遷移Controller // 状態遷移Controller
switch (s_RestoreState) switch (s_RestoreState)
{ {
// 起動時 // 起動時
case STARTUP: case STARTUP:
{ {
CheckSdInserted(manager, operationMessage, nextStep); CheckSdInserted(manager, operationMessage, nextStep);
} }
break; break;
case INITIALIZE_CONSOLE:
case INITIALIZE_CONSOLE:
{ {
COMMON_LOGGER("Initialize Console\n"); COMMON_LOGGER("Initialize Console\n");
@ -804,7 +804,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
CreateConsoleInitializedFile(); CreateConsoleInitializedFile();
// ファイルシステムの初期化を行う // ファイルシステムの初期化を行う
if (InitializeFileSystem()) if(InitializeFileSystem())
{ {
s_RestoreState = REBOOTING; s_RestoreState = REBOOTING;
} }
@ -816,7 +816,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case WAIT_START_UPDATE: case WAIT_START_UPDATE:
{ {
operationMessage.push_back(::std::string("Push A or START Button")); operationMessage.push_back(::std::string("Push A or START Button"));
operationMessage.push_back(::std::string("Network Update Mode")); operationMessage.push_back(::std::string("Network Update Mode"));
@ -834,13 +834,13 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case WAIT_START_IMPORT: case WAIT_START_IMPORT:
{ {
u8 serial[nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN]; u8 serial[nn::cfg::CTR::CFG_SECURE_INFO_SERIAL_NO_LEN];
result = ReadSerialNumber(serial); result = ReadSerialNumber(serial);
if (result.IsSuccess()) if (result.IsSuccess())
{ {
::std::string serialStr(reinterpret_cast<char*>(serial)); ::std::string serialStr(reinterpret_cast<char*> (serial));
operationMessage.push_back(::std::string("Serial Number in SD : ") + serialStr); operationMessage.push_back(::std::string("Serial Number in SD : ") + serialStr);
} }
else else
@ -860,7 +860,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case WAIT_START_SYNC_CLOCK: case WAIT_START_SYNC_CLOCK:
{ {
operationMessage.push_back(::std::string("Push A or START Button")); operationMessage.push_back(::std::string("Push A or START Button"));
operationMessage.push_back(::std::string("DownLoad Twl Title and Clock Sync Mode")); operationMessage.push_back(::std::string("DownLoad Twl Title and Clock Sync Mode"));
@ -878,7 +878,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case IMPORT_RTC: case IMPORT_RTC:
{ {
result = nn::ResultSuccess(); result = nn::ResultSuccess();
if (HasValidRtcData()) if (HasValidRtcData())
@ -914,8 +914,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// シリアルナンバーがSDカードにないこと警告 // シリアルナンバーがSDカードにないこと警告
case SERIAL_IS_NOT_IN_SD: case SERIAL_IS_NOT_IN_SD:
{ {
operationMessage.push_back(::std::string("Serial Number Is Not In SD Card")); operationMessage.push_back(::std::string("Serial Number Is Not In SD Card"));
operationMessage.push_back(::std::string("Push A or START Button")); operationMessage.push_back(::std::string("Push A or START Button"));
@ -931,15 +931,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// アップデート中 // アップデート中
case UPDATE_IN_PROGRESS: case UPDATE_IN_PROGRESS:
{ {
UpdateOperation(manager, operationMessage, UPDATE_DONE); UpdateOperation(manager, operationMessage, UPDATE_DONE);
} }
break; break;
// アップデート完了 // アップデート完了
case UPDATE_DONE: case UPDATE_DONE:
{ {
operationMessage.push_back(::std::string("Network Update Done.")); operationMessage.push_back(::std::string("Network Update Done."));
operationMessage.push_back(::std::string("Press A or START Button to Reboot")); operationMessage.push_back(::std::string("Press A or START Button to Reboot"));
@ -957,14 +957,15 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case DOWNLOAD_IVS: case DOWNLOAD_IVS:
{ {
ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_GET_IVS, "Get SDCI", ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_GET_IVS, "Get SDCI",
"Get SDCI Finished.\n", "Get SDCI Failed. Retrying...", DOWNLOAD_IVS_DONE); "Get SDCI Finished.\n", "Get SDCI Failed. Retrying...", DOWNLOAD_IVS_DONE);
} }
break; break;
case DOWNLOAD_IVS_DONE:
case DOWNLOAD_IVS_DONE:
{ {
operationMessage.push_back(::std::string("Get SDCI Done.")); operationMessage.push_back(::std::string("Get SDCI Done."));
operationMessage.push_back(::std::string("Press A or START Button to Reboot")); operationMessage.push_back(::std::string("Press A or START Button to Reboot"));
@ -982,13 +983,13 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case CHECK_IVS: case CHECK_IVS:
{ {
operationMessage.push_back(::std::string("Insert User's SD Card")); operationMessage.push_back(::std::string("Insert User's SD Card"));
} }
break; break;
case CHECK_SD_DIRECTORY: case CHECK_SD_DIRECTORY:
{ {
if (nn::fs::IsSdmcInserted()) if (nn::fs::IsSdmcInserted())
{ {
@ -1021,23 +1022,23 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case CHECK_SD_DIRECTORY_SUCCESS: case CHECK_SD_DIRECTORY_SUCCESS:
{ {
operationMessage.push_back(::std::string("Check User's SD Card Succeeded.")); operationMessage.push_back(::std::string("Check User's SD Card Succeeded."));
operationMessage.push_back(::std::string("Pull Out SD Card")); operationMessage.push_back(::std::string("Pull Out SD Card"));
} }
break; break;
case CHECK_SD_DIRECTORY_FAIL: case CHECK_SD_DIRECTORY_FAIL:
{ {
operationMessage.push_back(::std::string("Check User's SD Card Failed.")); operationMessage.push_back(::std::string("Check User's SD Card Failed."));
operationMessage.push_back(::std::string("Pull Out SD Card")); operationMessage.push_back(::std::string("Pull Out SD Card"));
} }
break; break;
case WAIT_START_TRANSFER_ACCOUNT: case WAIT_START_TRANSFER_ACCOUNT:
{ {
if (s_SkipNupMode) if(s_SkipNupMode)
{ {
operationMessage.push_back(::std::string("After Operating BMS Account Transfer,")); operationMessage.push_back(::std::string("After Operating BMS Account Transfer,"));
} }
@ -1058,21 +1059,21 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case TRANSFER_ACCOUNT: case TRANSFER_ACCOUNT:
{ {
ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_CONNECT, "Transfer Account", ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_CONNECT, "Transfer Account",
"Transfer Account Finished.\n", "Transfer Account Failed. Retrying...", TRANSFER_ACCOUNT_DONE); "Transfer Account Finished.\n", "Transfer Account Failed. Retrying...", TRANSFER_ACCOUNT_DONE);
} }
break; break;
case TRANSFER_ACCOUNT_DONE: case TRANSFER_ACCOUNT_DONE:
{ {
CreateTransferAccountFinishedFile(); CreateTransferAccountFinishedFile();
s_RestoreState = STARTUP; s_RestoreState = STARTUP;
} }
break; break;
case WAIT_START_DELETE_ACCOUNT: case WAIT_START_DELETE_ACCOUNT:
{ {
operationMessage.push_back(::std::string("Push A or START Button")); operationMessage.push_back(::std::string("Push A or START Button"));
operationMessage.push_back(::std::string("Delete Account Mode")); operationMessage.push_back(::std::string("Delete Account Mode"));
@ -1090,13 +1091,12 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case DELETE_ACCOUNT: case DELETE_ACCOUNT:
{ {
if (s_NupOnlyMode) if(s_NupOnlyMode)
{ {
ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_FORCE_UNREGISTER, ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_FORCE_UNREGISTER, "Deleting Account",
"Deleting Account", "Delete Account Finished.\n", "Delete Account Failed. Retrying...", "Delete Account Finished.\n", "Delete Account Failed. Retrying...", DELETE_ACCOUNT_DONE);
DELETE_ACCOUNT_DONE);
} }
else else
@ -1107,9 +1107,9 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case DELETE_ACCOUNT_DONE: case DELETE_ACCOUNT_DONE:
{ {
if (s_NupOnlyMode) if(s_NupOnlyMode)
{ {
s_RestoreState = NUP_ONLY_WAIT_SD_EJECT; s_RestoreState = NUP_ONLY_WAIT_SD_EJECT;
@ -1137,7 +1137,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case READ_FILELIST: case READ_FILELIST:
{ {
result = SetupFileList(); result = SetupFileList();
COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result); COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
@ -1161,8 +1161,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// TWLサウンド領域の書き込み中 // TWLサウンド領域の書き込み中
case RESTORE_TWL_SOUND: case RESTORE_TWL_SOUND:
{ {
static bool init = true; static bool init = true;
if (init) if (init)
@ -1178,7 +1178,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (IsImportThreadFinished()) if (IsImportThreadFinished())
{ {
FinalizeImportThread(); FinalizeImportThread();
if (IsImportSucceeded()) if(IsImportSucceeded())
{ {
s_RestoreState = RESTORE_TWL_PHOTO; s_RestoreState = RESTORE_TWL_PHOTO;
} }
@ -1186,12 +1186,13 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
{ {
s_RestoreState = FAIL; s_RestoreState = FAIL;
} }
} }
} }
break; break;
// TWL写真領域の書き込み // TWL写真領域の書き込み
case RESTORE_TWL_PHOTO: case RESTORE_TWL_PHOTO:
{ {
static bool init = true; static bool init = true;
if (init) if (init)
@ -1207,7 +1208,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (IsImportThreadFinished()) if (IsImportThreadFinished())
{ {
FinalizeImportThread(); FinalizeImportThread();
if (IsImportSucceeded()) if(IsImportSucceeded())
{ {
s_RestoreState = RESTORE_IN_PROGRESS; s_RestoreState = RESTORE_IN_PROGRESS;
} }
@ -1220,8 +1221,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// 書き込み中 // 書き込み中
case RESTORE_IN_PROGRESS: case RESTORE_IN_PROGRESS:
{ {
// ACアダプタが必要か？ // ACアダプタが必要か？
if (NeedsAcAdater(manager)) if (NeedsAcAdater(manager))
@ -1241,7 +1242,6 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
// 処理が完了した // 処理が完了した
if (!NeedsAcAdater(manager) && IsImportThreadFinished()) if (!NeedsAcAdater(manager) && IsImportThreadFinished())
{ {
FinalizeImportThread();
if (IsImportSucceeded()) if (IsImportSucceeded())
{ {
@ -1249,7 +1249,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
if (GetProgress() > 99) if (GetProgress() > 99)
{ {
s_RestoreState = RESTORE_TEST; s_RestoreState = POST_RESTORE;
} }
else else
{ {
@ -1265,8 +1265,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// リブート中 // リブート中
case REBOOTING: case REBOOTING:
{ {
static bool init = true; static bool init = true;
@ -1293,39 +1293,13 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case RESTORE_TEST: // 書き込み後の処理
{ case POST_RESTORE:
PutAliveMessage(operationMessage, "Checking Data");
static bool init = true;
if (init)
{
TestCtrData();
init = false;
}
if (IsImportThreadFinished())
{
FinalizeImportThread();
if (IsImportSucceeded())
{
s_RestoreState = POST_RESTORE;
}
else
{
s_RestoreState = FAIL;
}
}
}
break;
// 書き込み後の処理
case POST_RESTORE:
{ {
operationMessage.push_back(::std::string("Post Process...")); operationMessage.push_back(::std::string("Post Process..."));
// SDカードのIVSファイルを書き込む // SDカードのIVSファイルを書き込む
if (ImportIvsData()) if(ImportIvsData())
{ {
// 書き込み完了ファイルを作成 // 書き込み完了ファイルを作成
CreateWriteFinishedFile(); CreateWriteFinishedFile();
@ -1339,8 +1313,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// 書き込み完了 // 書き込み完了
case RESTORE_DONE: case RESTORE_DONE:
{ {
operationMessage.push_back(::std::string("Restore Done.")); operationMessage.push_back(::std::string("Restore Done."));
operationMessage.push_back(::std::string("Press A or START Button to Reboot")); operationMessage.push_back(::std::string("Press A or START Button to Reboot"));
@ -1358,16 +1332,16 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// 削除処理 // 削除処理
case ERASE: case ERASE:
{ {
Cleanup(); Cleanup();
s_RestoreState = RESTORE_CAL; s_RestoreState = RESTORE_CAL;
} }
break; break;
// 削除処理 // 削除処理
case RESTORE_CAL: case RESTORE_CAL:
{ {
// ptmのセーブデータ移行後に時計を無効化する // ptmのセーブデータ移行後に時計を無効化する
nn::ptm::CTR::InvalidateSystemTime(); nn::ptm::CTR::InvalidateSystemTime();
@ -1384,9 +1358,9 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case SYNC_TICKET: case SYNC_TICKET:
{ {
if (s_GetIvsOnlyMode) if(s_GetIvsOnlyMode)
{ {
ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_CONNECT, "Shop Connect", ShopOperationSingleTemplate(manager, operationMessage, SHOP_OPERATION_CONNECT, "Shop Connect",
"Shop Connect Finished.\n", "Shop Connect Failed. Retrying...", WAIT_SD_EJECT); "Shop Connect Finished.\n", "Shop Connect Failed. Retrying...", WAIT_SD_EJECT);
@ -1399,10 +1373,10 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case DOWNLOAD_TWL: case DOWNLOAD_TWL:
{ {
// ファイルリストがなければ次へ // ファイルリストがなければ次へ
if (!ExistsTwlTitleListFile()) if( !ExistsTwlTitleListFile())
{ {
s_IsSyncClock = true; s_IsSyncClock = true;
s_RestoreState = READ_FILELIST; s_RestoreState = READ_FILELIST;
@ -1449,8 +1423,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// TWL NAND領域の書き込み中 // TWL NAND領域の書き込み中
case RESTORE_TWL_NAND: case RESTORE_TWL_NAND:
{ {
static bool init = true; static bool init = true;
if (init) if (init)
@ -1471,8 +1445,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// 時計あわせ // 時計あわせ
case TIME_ADJUST: case TIME_ADJUST:
{ {
static bool init = true; static bool init = true;
if (init) if (init)
@ -1504,8 +1478,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// すべて完了 // すべて完了
case WAIT_SD_EJECT: case WAIT_SD_EJECT:
{ {
operationMessage.push_back(::std::string("ALL Done. Pull Out SD Card.")); operationMessage.push_back(::std::string("ALL Done. Pull Out SD Card."));
// SDカード抜けのみで次の状態に遷移する // SDカード抜けのみで次の状態に遷移する
@ -1519,8 +1493,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// すべて完了 // すべて完了
case ALL_DONE: case ALL_DONE:
{ {
operationMessage.push_back(::std::string("Restore Succeeded!!")); operationMessage.push_back(::std::string("Restore Succeeded!!"));
static bool init = true; static bool init = true;
@ -1532,8 +1506,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
// 書き込み失敗 // 書き込み失敗
case FAIL: case FAIL:
{ {
static bool init = true; static bool init = true;
if (init) if (init)
@ -1552,7 +1526,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case NUP_ONLY_WAIT_SD_EJECT: case NUP_ONLY_WAIT_SD_EJECT:
{ {
operationMessage.push_back(::std::string("Update Done. Pull Out SD Card.")); operationMessage.push_back(::std::string("Update Done. Pull Out SD Card."));
@ -1565,10 +1539,10 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case DOWNLOAD_IVS_WAIT_NEXT: case DOWNLOAD_IVS_WAIT_NEXT:
{ {
operationMessage.push_back(::std::string("Press A or START Button to Continue.")); operationMessage.push_back(::std::string("Press A or START Button to Continue."));
if (nextStep) if(nextStep)
{ {
s_RestoreState = SYNC_TICKET; s_RestoreState = SYNC_TICKET;
DeleteAllCheckFiles(); DeleteAllCheckFiles();
@ -1576,7 +1550,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case NUP_ONLY_WAIT_NEXT: case NUP_ONLY_WAIT_NEXT:
{ {
operationMessage.push_back(::std::string("Press A or START Button to Shutdown.")); operationMessage.push_back(::std::string("Press A or START Button to Shutdown."));
@ -1587,10 +1561,10 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
} }
break; break;
case INITIALIZE_AND_SHUTDOWN: case INITIALIZE_AND_SHUTDOWN:
{ {
// 本体初期化を行う // 本体初期化を行う
if (!InitializeFileSystem()) if(!InitializeFileSystem())
{ {
s_RestoreState = FAIL; s_RestoreState = FAIL;
} }
@ -1599,6 +1573,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
nn::ptm::CTR::ShutdownAsync(0, nn::fnd::TimeSpan::FromSeconds(0)); nn::ptm::CTR::ShutdownAsync(0, nn::fnd::TimeSpan::FromSeconds(0));
} }
break; break;
} }
} }
@ -1690,7 +1665,6 @@ u32 GetProgress()
s_RestoreState == RESTORE_TWL_NAND || s_RestoreState == RESTORE_TWL_NAND ||
s_RestoreState == RESTORE_IN_PROGRESS || s_RestoreState == RESTORE_IN_PROGRESS ||
s_RestoreState == POST_RESTORE || s_RestoreState == POST_RESTORE ||
s_RestoreState == RESTORE_TEST ||
s_RestoreState == RESTORE_DONE) s_RestoreState == RESTORE_DONE)
{ {
return GetImportProgress(); return GetImportProgress();

107
branches/work/RW_Aging/sources/ConsoleRestore/Importer.cpp
View File

@ -16,7 +16,6 @@
#include <nn.h> #include <nn.h>
#include <nn/fs/CTR/fs_ArchiveTypesForSystem.h> #include <nn/fs/CTR/fs_ArchiveTypesForSystem.h>
#include <nn/fs/CTR/MPCore/fs_FileSystemBasePrivate.h> #include <nn/fs/CTR/MPCore/fs_FileSystemBasePrivate.h>
#include <nn/fs/CTR/MPCore/fs_ApiIntegrityVerificationSeed.h>
#include <nn/cfg/CTR/cfg_ApiInit.h> #include <nn/cfg/CTR/cfg_ApiInit.h>
#include <nn/cfg/CTR/cfg_ApiNor.h> // cfg:norの初期化に必要 #include <nn/cfg/CTR/cfg_ApiNor.h> // cfg:norの初期化に必要
#include <nn/cfg/CTR/cfg_Api.h> #include <nn/cfg/CTR/cfg_Api.h>
@ -623,43 +622,6 @@ bool InitializeFileSystem()
return true; return true;
} }
nn::Result GetNewIvs(void* oldBuf, size_t oldBufSize, void* newBuf, size_t newBufSize, size_t* newIvsSize)
{
if (oldBufSize < nn::fs::CTR::SIZE_INTEGRITY_VERIFICATION_SEED
|| newBufSize < nn::fs::CTR::SIZE_INTEGRITY_VERIFICATION_SEED
|| oldBuf == NULL || newBuf == NULL
)
{
return nn::Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_OUT_OF_RESOURCE, nn::Result::MODULE_COMMON,
nn::Result::DESCRIPTION_OUT_OF_MEMORY);
}
nn::Result result;
result = common::SdMountManager::Mount();
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
common::SdReaderWriter sdReader;
size_t readSize;
result = sdReader.ReadBufWithCmac(common::IVS_PATHNAME, oldBuf, oldBufSize, &readSize);
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
*newIvsSize = readSize;
// AES復号化する
nn::crypto::Initialize();
nn::crypto::SwAesCtrContext swAesCtrContest;
swAesCtrContest.Initialize(common::iv, common::key, sizeof(common::key));
result = swAesCtrContest.Decrypt(newBuf, oldBuf, readSize);
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
nn::crypto::Finalize();
result = common::SdMountManager::Unmount();
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
return nn::ResultSuccess();
}
nn::Result ImportIvs() nn::Result ImportIvs()
{ {
nn::Result result = nn::ResultSuccess(); nn::Result result = nn::ResultSuccess();
@ -674,7 +636,7 @@ nn::Result ImportIvs()
size_t readSize; size_t readSize;
result = sdReader.ReadBufWithCmac(common::IVS_PATHNAME, enc, bufSize, &readSize); result = sdReader.ReadBufWithCmac(common::IVS_PATHNAME, enc, bufSize, &readSize);
if (result.IsSuccess()) if(result.IsSuccess())
{ {
// SDから読み出し成功 // SDから読み出し成功
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);
@ -770,7 +732,6 @@ void ImportThreadFunc()
NN_LOG("Import Thread Finalize\n"); NN_LOG("Import Thread Finalize\n");
} }
namespace namespace
{ {
@ -1895,72 +1856,6 @@ bool IsImportSucceeded()
return s_IsImportSucceeded; return s_IsImportSucceeded;
} }
nn::Result GetNewSaveDirRoot(std::wstring& sysSaveRoot)
{
nn::Result result;
const size_t BUF_SIZE = 1024;
common::HeapManager oldBuf(BUF_SIZE);
common::HeapManager newBuf(BUF_SIZE);
size_t ivsSize;
result = GetNewIvs(oldBuf.GetAddr(), BUF_SIZE, newBuf.GetAddr(), BUF_SIZE, &ivsSize);
COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
std::string root;
common::Util::GetSaveDataDirectoryRoot(root, newBuf.GetAddr(), ivsSize);
wchar_t rootName[256];
std::mbstowcs(rootName, root.c_str(), root.size() + 1);
sysSaveRoot = rootName;
return nn::ResultSuccess();
}
void TestCtrDataThreadFunc()
{
nn::Result result;
s_IsImportSucceeded = true;
// 新IVSディレクトリを取得
std::wstring sysSaveRoot;
result = GetNewSaveDirRoot(sysSaveRoot);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
u32 fileNum = 0;
s64 fileSize = 0;
result = common::CalculateFileNum(
::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH) + sysSaveRoot + std::wstring(L"/"), fileNum,
fileSize);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
common::InitializeTransferProgress(fileSize);
size_t bufSize = common::GetAllocatableSize(AES_BLOCK_SIZE);
common::HeapManager buf(bufSize, AES_BLOCK_SIZE);
if(!common::TestReadDirectory((std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH) + sysSaveRoot + std::wstring(L"/")).c_str(), buf.GetAddr(), bufSize
))
{
s_IsImportSucceeded = false;
return;
}
result = nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
COMMON_LOGGER_RETURN_VOID_SET_BOOL_IF_FAILED(result, s_IsImportSucceeded);
}
void TestCtrData()
{
COMMON_LOGGER("Test NAND Data Start...\n");
s_ImportThread.Start(TestCtrDataThreadFunc, s_ImportThreadStack);
}
nn::Result ImportData() nn::Result ImportData()
{ {
static nn::Result result = nn::ResultSuccess(); static nn::Result result = nn::ResultSuccess();

3
branches/work/RW_Aging/sources/ConsoleRestore/Importer.h
View File

@ -160,9 +160,6 @@ bool ImportIvsData();
// 書き込みが成功したかどうか // 書き込みが成功したかどうか
bool IsImportSucceeded(); bool IsImportSucceeded();
// 新たにスレッドを立て、CTR-NAND領域をテストする
void TestCtrData();
} }
#endif /* IMPORTER_H_ */ #endif /* IMPORTER_H_ */

4
branches/work/RW_Aging/sources/common/CommonLogger.h
View File

@ -93,6 +93,10 @@
return; \ return; \
} \ } \
#define COMMON_LOGGER_RETURN_FALSE(result) \
COMMON_LOGGER_RESULT_WITH_LINE(result, __LINE__, __func__); \
return false; \
namespace common namespace common
{ {

85
branches/work/RW_Aging/sources/common/FileTransfer.cpp
View File

@ -674,6 +674,7 @@ bool ConfirmFile(nn::fs::FileInputStream* from_file, nn::fs::FileStream* to_file
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_RETURN_FALSE_IF_FAILED(result); COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
return false;
} }
else else
{ {
@ -767,88 +768,4 @@ bool AddPathNameAndUpdateContext(nn::fs::FileOutputStream* file, const wchar_t *
return true; return true;
} }
bool TestReadDirectory(const wchar_t* path, void* buf, const size_t bufSize)
{
nn::fs::Directory dir;
nn::fs::DirectoryEntry entry;
s32 numread = 0;
std::wostringstream targetStream;
NN_LOG("Read Directory %ls\n", path);
nn::Result result = dir.TryInitialize(path);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
while (1)
{
result = dir.TryRead(&numread, &entry, 1);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if(numread == 0)
{
break;
}
if (std::wcscmp(entry.entryName, L".") == 0 || std::wcscmp(entry.entryName, L"..") == 0)
{
continue;
}
targetStream.str(L"");
targetStream.clear(std::stringstream::goodbit);
targetStream << path << entry.entryName;
// ディレクトリの場合
if (entry.attributes.isDirectory)
{
targetStream << L"/";
// 再帰処理
if (!TestReadDirectory(targetStream.str().c_str(), buf, bufSize))
{
return false;
}
}
// ファイルの場合
else
{
// ファイル作成
nn::fs::FileInputStream file;
s64 filesize;
s32 readsize;
NN_LOG("Read File %ls\n", targetStream.str().c_str());
// 読み込み対象ファイル開く
result = file.TryInitialize(targetStream.str().c_str());
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
// 読み込み対象ファイルのサイズ取得
result = file.TryGetSize(&filesize);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
// ファイル全体を読みきるまでループ
while (1)
{
result = file.TryRead(&readsize, buf, bufSize);
COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
if (readsize == 0)
{
break;
}
else
{
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);
}
}
}
}
return true;
}
} }

3
branches/work/RW_Aging/sources/common/FileTransfer.h
View File

@ -57,9 +57,6 @@ void InitializeTransferProgress(u64 totalSize);
// 内部のバッファを使用するためスレッドアンセーフ // 内部のバッファを使用するためスレッドアンセーフ
const char* GetCharStr(const wchar_t* path); const char* GetCharStr(const wchar_t* path);
// pathで指定したディレクトリ以下を再帰的に読み込んでエラーが発生しないかテストする
bool TestReadDirectory(const wchar_t* path, void* buf, const size_t bufSize);
} }
#endif /* FILETRANSFER_H_ */ #endif /* FILETRANSFER_H_ */