ctr_test_tools/TwlBackupChecker/CTR/DataExportImportTool/sdAccessor.cpp

#include "sdAccessor.h"
#include "draw.h"

const bit32 CLEAR = 0x00000000;//追加情報なし
const bit32 CLEAR_INFO = 0x08000000;//追加情報あり

SdAccessor::SdAccessor():
                        mImportCount(0),
                        mExportCount(0),
                        mIsImportAll(false),
                        mIsSdMount(false)
{
    mEntryMax = sizeof(mBinary.binaryType)/sizeof(mBinary.binaryType[0]);
    for(u16 i = 0; i < mEntryMax; i++)
    {
        mBinary.binaryType[i].state = IMPORTED_NOT;
    }
    for(u16 i = 0; i < 512; i++)
    {
        mFileName[i] = L'\0';
    }
    mBinary.size = 0;
    mDirectory.size = 0;
}


static bool directoryEntryComp(const nn::fs::DirectoryEntry &lhs, const nn::fs::DirectoryEntry &rhs)
{
    return std::wcscmp(lhs.entryName, rhs.entryName) < 0;
}

static bool binaryInfoComp(const SdAccessor::BinaryType &lhs, const SdAccessor::BinaryType &rhs)
{
    return directoryEntryComp(lhs.directoryEntry, rhs.directoryEntry);
}

void SdAccessor::Initialize(nn::fs::Directory& dir, wchar_t* fileName)
{
    std::wcscpy(mFileName,fileName);
    DirectoryInitialize(dir);
}

void SdAccessor::DirectoryInitialize(nn::fs::Directory& dir)
{
    mBinary.size = 0;
    mExportCount = 0;
    mImportCount = 0;
    mIsImportAll = false;

    for(u16 i = 0; i < mEntryMax; i++)
    {
        mBinary.binaryType[i].state = IMPORTED_NOT;
    }
    std::wcscpy(mDirectory.directoryEntry[0].entryName, L"../");
    nn::fs::DirectoryEntry* entry = new nn::fs::DirectoryEntry[mEntryMax];
    dir.Initialize(mFileName);
    s32 readCount = dir.Read(entry,mEntryMax);
    if(readCount == 0)
    {
        mBinary.size= 0;
        mDirectory.size = 1;
    }
    else
    {
        u16 j = 0;
        u16 k = 1;
        //バイナリファイル・フォルダに分割
        for(u16 i = 0; i < readCount; i++)
        {
            if(entry[i].shortName.valid)
            {
                if(std::strcmp(entry[i].shortName.ext, "BIN") == 0)
                {
                    mBinary.binaryType[j].directoryEntry = entry[i];
                    j++;
                }
                if(entry[i].attributes.isDirectory)
                {
                    mDirectory.directoryEntry[k] = entry[i];
                    k++;
                }
            }
        }
        mBinary.size = j;
        mDirectory.size = k;
        //フォルダ・ファイルそれぞれソート
        std::sort(&mBinary.binaryType[0], &mBinary.binaryType[mBinary.size], binaryInfoComp);
        std::sort(&mDirectory.directoryEntry[0], &mDirectory.directoryEntry[mDirectory.size], directoryEntryComp);
    }
    delete[] entry;
}


void SdAccessor::Add(u16 index)
{
    if(index == 0)
    {
        if( std::wcscmp(mFileName, L"sdmc:/") != 0)
        {
            size_t directoryLen,i;
            directoryLen = std::wcslen(mFileName);
            mFileName[directoryLen - 1] = L'\0';
            for(i = directoryLen - 2; mFileName[i] != L'/';i--)
            {
                mFileName[i] = L'\0';
            }
        }
    }
    else if (mDirectory.size != 1)
    {
        std::wcscat(mFileName,mDirectory.directoryEntry[index].entryName);
        std::wcscat(mFileName,L"/");
    }
}

void SdAccessor::Import(u16 index,bit8* addrForAm)
{
    std::wcscpy(mBinaryName, mFileName);
    std::wcscat(mBinaryName, mBinary.binaryType[index].directoryEntry.entryName);
    mBinary.binaryType[index].result = nn::am::ImportTwlBackup(mBinaryName, addrForAm);
    if(mBinary.binaryType[index].result.GetPrintableBits() == CLEAR || mBinary.binaryType[index].result.GetPrintableBits() == CLEAR_INFO)
    {
        mBinary.binaryType[index].state = IMPORTED_CLEAR;
    }
    else
    {
        mBinary.binaryType[index].state = IMPORTED_ERROR;
    }
}

void SdAccessor::ImportAll(bit8* addrForAm)
{
    if (mImportCount == 0) {
        mIsImportAll = true;
    }
    Import(mImportCount, addrForAm);
    mImportCount++;
    if (mImportCount >= mBinary.size) {
        mImportCount = 0;
        mIsImportAll = false;
    }
}
//全ファイル結果保存
void SdAccessor::ExportAll(void)
{
    wchar_t exportPath[128];
    wchar_t outFileName[32];
    char c_buffer[1024];
    u16 fileSize = 256;
    s32 ret,ret2;
    nn::fs::FileStream f;
    std::wcscpy(exportPath,mFileName);
    std::swprintf(outFileName,32,L"Result%d.csv",mExportCount);
    std::wcscat(exportPath,outFileName);
    mExportCount++;
    nn::Result resultFile = f.TryInitialize(exportPath, nn::fs::OPEN_MODE_READ);
    if( !resultFile.IsSuccess() )
    {
        resultFile = nn::fs::TryCreateFile(exportPath, fileSize);
        NN_UTIL_PANIC_IF_FAILED(resultFile);
        resultFile = f.TryInitialize(exportPath, nn::fs::OPEN_MODE_READ);
        NN_UTIL_PANIC_IF_FAILED(resultFile);
    }
    resultFile = f.TrySeek(0,nn::fs::POSITION_BASE_BEGIN);
    NN_UTIL_PANIC_IF_FAILED(resultFile);

    resultFile = f.TryRead(&ret,c_buffer,sizeof(c_buffer));
    NN_UTIL_PANIC_IF_FAILED(resultFile);
    for(u16 i = 0; i < ret ; i++)
    {
        c_buffer[i] = '\0';
    }
    f.Finalize();
    resultFile = f.TryInitialize(exportPath, nn::fs::OPEN_MODE_WRITE);
    NN_UTIL_PANIC_IF_FAILED(resultFile);
    resultFile = f.TrySeek(0,nn::fs::POSITION_BASE_BEGIN);
    NN_UTIL_PANIC_IF_FAILED(resultFile);
    resultFile = f.TryWrite(&ret2,c_buffer,ret);
    NN_UTIL_PANIC_IF_FAILED(resultFile);
    resultFile = f.TrySeek(0,nn::fs::POSITION_BASE_BEGIN);
    NN_UTIL_PANIC_IF_FAILED(resultFile);

    std::strcpy(c_buffer,"File,Level,Summary,Module,Description\n");
    resultFile = f.TryWrite(&ret,c_buffer,std::strlen(c_buffer));
    NN_UTIL_PANIC_IF_FAILED(resultFile);


    for(u16 i = 0; i < mBinary.size; i++)
    {
        if(mBinary.binaryType[i].state != IMPORTED_NOT)
        {
            nn::Result result = mBinary.binaryType[i].result;
            std::sprintf(c_buffer, "%ls,%s (%d),%s (%d),%s (%d),%s (%d)\n"
                    ,mBinary.binaryType[i].directoryEntry.entryName
                    ,nn::dbg::GetLevelString(result)
            ,result.GetLevel()
            ,nn::dbg::GetSummaryString(result)
            ,result.GetSummary()
            ,nn::dbg::GetModuleString(result)
            ,result.GetModule()
            ,nn::dbg::GetDescriptionString(result)
            ,result.GetDescription()
            );
            resultFile = f.TryWrite(&ret,c_buffer,std::strlen(c_buffer));
            NN_UTIL_PANIC_IF_FAILED(resultFile);
        }
    }
    f.Finalize();
}