ctr_Repair/trunk/ConsoleDataMigration/sources/ConsoleRestore/ActCompleter.cpp

/*---------------------------------------------------------------------------*
 Project:  Horizon
 File:     ActCompleter.cpp

 Copyright (C)2013 Nintendo Co., Ltd.  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 "ActCompleter.h"
#include "Util.h"
#include "CommonLogger.h"
#include "HeapManager.h"
#include <nn/ac/CTR/private/ac_InternalApi.h>
#include <nn/act/act_ApiAdmin.h>
#include <nn/act/act_ApiTransfer.h>
#include <nn/act/act_ResultPrivate.h>
#include <nn/actslv/actslv_Api.h>
#include <nn/fs/fs_ApiSysSaveData.h>
#include <nn/cfg/CTR/cfg_ApiSys.h>

#include "AgeChecker.h"

namespace ConsoleRestore
{
nn::Result ActCompleter::s_Result;
const size_t ActCompleter::STACK_SIZE;
nn::os::Thread ActCompleter::s_Thread;
nn::os::Thread ActCompleter::s_UnmountThread;
nn::os::StackBuffer<ActCompleter::STACK_SIZE> ActCompleter::s_ThreadStack;
nn::os::StackBuffer<ActCompleter::STACK_SIZE> ActCompleter::s_UnmountThreadStack;
nn::os::Event ActCompleter::s_BeginEvent;
nn::os::Event ActCompleter::s_EndEvent;
u32 ActCompleter::s_ApprovalId;
ActCompleter::CompleteMode ActCompleter::s_Mode;
ActCompleter::SalvageCheck ActCompleter::s_SalvageCheck;


ActCompleter::ActCompleter()
{
}

ActCompleter::~ActCompleter()
{
}

nn::Result ActCompleter::GetResult()
{
    return s_Result;
}

void ActCompleter::Start(CompleteMode mode, SalvageCheck check)
{
    s_Mode = mode;
    s_SalvageCheck = check;
    s_ApprovalId = 0;
    if(s_Mode == ACT_COMPLETE_TRANSFER_WITH_SALVEGE)
    {
        s_BeginEvent.Initialize(false);
        s_EndEvent.Initialize(false);
    }

    s_Thread.Start(Exec, s_ThreadStack);
}

bool ActCompleter::IsFinished()
{
    return s_Thread.IsValid() && !s_Thread.IsAlive();
}

void ActCompleter::Finish()
{
    if(s_Thread.IsValid())
    {
        s_Thread.Join();
        s_Thread.Finalize();
    }
    if(s_Mode == ACT_COMPLETE_TRANSFER_WITH_SALVEGE)
    {
        if(s_UnmountThread.IsValid())
        {
            s_UnmountThread.Join();
            s_UnmountThread.Finalize();
        }
        s_BeginEvent.Finalize();
        s_EndEvent.Finalize();
    }
}

void ActCompleter::Exec()
{
    s_Result = ExecImpl();
}

void ActCompleter::UnmountThreadFunc()
{
    nn::act::KeepUnmountAndBlock( &s_BeginEvent, &s_EndEvent );
}

nn::Result ActCompleter::ExecImpl()
{
    if(!nn::ac::IsConnected())
    {
        NN_UTIL_RETURN_IF_FAILED(
                common::InitializeNetwork());
    }

    NN_UTIL_RETURN_IF_FAILED(
            nn::act::InitializeAdmin());

    if (s_Mode == ACT_COMPLETE_TRANSFER_WITH_SALVEGE)
    {
        // アンマウント
        s_UnmountThread.Start(UnmountThreadFunc, s_UnmountThreadStack);
        s_BeginEvent.Wait();

        // アンマウントできたのでアカウントサルベージを実行
        nn::Result result = nn::act::SalvageAccounts();
        // サルベージ終了をシステムに通知
        s_EndEvent.Signal();

        if(result.IsFailure())
        {
            if(nn::act::ResultRequestNotFound().Includes(result) && s_SalvageCheck == ACT_SALVAGE_WITHOUT_CHECK)
            {
                //サルベージ結果を無視するモードなので無視
            }
            else
            {
                NN_UTIL_RETURN_IF_FAILED_1(
                        nn::act::FinalizeAdmin(),
                        common::FinalizeNetwork());

                NN_UTIL_RETURN_IF_FAILED(
                        common::FinalizeNetwork());

                return result;
            }
        }
        else
        {
            // COPPA判定とPIN判定の準備
            nn::cfg::CfgRegionCode region = nn::cfg::GetRegion();
            u8 age = nn::act::GetAgeAtSalvage();
            nn::cfg::CfgCountryCode country;

            NN_UTIL_RETURN_IF_FAILED_2(
                    nn::act::GetCountryCodeAtSalvage(reinterpret_cast<u32*>(&country)),
                    nn::act::FinalizeAdmin(),
                    common::FinalizeNetwork());

            AgeChecker ageChecker;

            if (region == nn::cfg::CFG_REGION_AMERICA)
            {

                if (ageChecker.IsCoppaRequired(age, region, country))
                {
                    // COPPA対象の年齢なら復元する
                    s_ApprovalId = nn::act::GetSalvagedApprovalId();
                    NN_UTIL_RETURN_IF_FAILED_2(
                            SaveApprovalId(),
                            nn::act::FinalizeAdmin(),
                            common::FinalizeNetwork());
                }
            }

            // PIN必須ならフラグを立てる
            if (ageChecker.IsPinRestrictionRequired(age, region, country))
            {
                NN_UTIL_RETURN_IF_FAILED_2(
                        nn::cfg::CTR::system::SetForceParentalControlFlag(true),
                        nn::act::FinalizeAdmin(),
                        common::FinalizeNetwork());

                NN_UTIL_RETURN_IF_FAILED_2(
                        nn::cfg::CTR::system::FlushConfig(),
                        nn::act::FinalizeAdmin(),
                        common::FinalizeNetwork());
            }
        }
    }

    // 移行完了
    // サルベージの有無に関わらず呼び出す
    NN_UTIL_RETURN_IF_FAILED_2(
            nn::act::CompleteTransfer(),
            nn::act::FinalizeAdmin(),
            common::FinalizeNetwork());

    NN_UTIL_RETURN_IF_FAILED_1(
            nn::act::FinalizeAdmin(),
            common::FinalizeNetwork());

    NN_UTIL_RETURN_IF_FAILED(
            common::FinalizeNetwork());

    return nn::ResultSuccess();
}

nn::Result ActCompleter::SaveApprovalId()
{
    // Cave-accountのシステムセーブデータ設定
    const u32 CAVE_ACCOUNT_US_SAVEDATA_ID = 0x000202C0;
    const u32 MAX_FILES = 5;
    const u32 MAX_DIRECTORIES = 1;
    const u32 SAVE_DATA_SIZE = 512 * 1024;

    // Cave-accountのファイル書き込み設定
    const char* const SYSTEM_SAVEDATA_ARCHIVE_NAME = "ssave:";
    const char* const CAVE_FILE_NAME = "ssave:/s.bin";
    const size_t CAVE_FILE_SIZE = 143360;
    const u32 APPROVAL_ID_OFFSET = 0x11000;

    NN_UTIL_RETURN_IF_FAILED(
            nn::fs::CreateSystemSaveData(CAVE_ACCOUNT_US_SAVEDATA_ID, MAX_FILES, MAX_DIRECTORIES, SAVE_DATA_SIZE, true));

    NN_UTIL_RETURN_IF_FAILED(
            nn::fs::MountSystemSaveData(SYSTEM_SAVEDATA_ARCHIVE_NAME, CAVE_ACCOUNT_US_SAVEDATA_ID));

    {
        nn::fs::FileOutputStream out(CAVE_FILE_NAME, true);

        // ファイルサイズ分のダミーデータを書く
        common::HeapManager dummyWriteData(CAVE_FILE_SIZE);
        void* buf = dummyWriteData.GetAddr();
        if(buf != NULL)
        {
            std::memset(buf, 0, CAVE_FILE_SIZE);
            s32 writeSize;
            NN_UTIL_RETURN_IF_FAILED_1(
                    out.TryWrite(&writeSize, buf, CAVE_FILE_SIZE, true),
                    nn::fs::Unmount(SYSTEM_SAVEDATA_ARCHIVE_NAME));
        }
        else
        {
            return nn::Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_OUT_OF_RESOURCE, nn::Result::MODULE_COMMON,
                    nn::Result::DESCRIPTION_OUT_OF_MEMORY);
        }

        NN_UTIL_RETURN_IF_FAILED_1(
                out.TrySeek(APPROVAL_ID_OFFSET, nn::fs::POSITION_BASE_BEGIN),
                nn::fs::Unmount(SYSTEM_SAVEDATA_ARCHIVE_NAME));
        s32 writeSize;
        NN_UTIL_RETURN_IF_FAILED_1(
                out.TryWrite(&writeSize, &s_ApprovalId, sizeof(s_ApprovalId), true),
                nn::fs::Unmount(SYSTEM_SAVEDATA_ARCHIVE_NAME));

        NN_UTIL_RETURN_IF_FAILED_1(
                nn::fs::CommitSystemSaveData(SYSTEM_SAVEDATA_ARCHIVE_NAME),
                nn::fs::Unmount(SYSTEM_SAVEDATA_ARCHIVE_NAME));
    }

    NN_UTIL_RETURN_IF_FAILED(
            nn::fs::Unmount(SYSTEM_SAVEDATA_ARCHIVE_NAME));

    return nn::ResultSuccess();
}

} /* namespace ConsoleRestore */