// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32test\server\t_fatcorrupt.cpp

//

//

//! @SYMTestCaseID FSBASE-CR-JHAS-68YPX7

//! @SYMTestType CT

//! @SYMREQ CR JHAS-68YPX7

//! @SYMTestCaseDesc Test functionality of handling corrupt data on disk

//! @SYMTestStatus Implemented

//! @SYMTestActions Use fat test extension to test read/write/format

//! @SYMTestExpectedResults Read bad sector fail, others pass

//! @SYMTestPriority Medium

//! @SYMAuthor Ying Shi

//! @SYMCreationDate 20/05/2005

//! @See EFat and EFat32 components

//! @file f32test\server\t_fatcorrupt.cpp

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include "t_server.h"

#include "t_fatext.h"

using namespace Fat_Test_Utils;

GLDEF_D RTest test(_L("T_FATCORRUPT"));

static TInt gDrive;

static TBuf16<2> gDriveName(2);

static TFileName gFileSystem;

static TFullName gExtName;

static TBool gExtExists=EFalse;

static TFatBootSector BootSector;

static TInt gBadList[3];

_LIT(KExtName,"FATTEST");

void RestoreEnv();

/**

    Do format steps and print progress

    @param  aFormat     specifies the format object

    @param  aStepsCnt   format steps counter from RFormat::Open

    @return format completion error code

*/

static TInt DoFormatSteps(RFormat& aFormat, TInt aStepsCnt)

{

    TInt nRes = KErrNone;

    TInt prevCnt = aStepsCnt;

    while (aStepsCnt && nRes == KErrNone)

        {

         if(prevCnt != aStepsCnt)

            {

            test.Printf(_L("."));

            prevCnt = aStepsCnt;

            }

        nRes = aFormat.Next(aStepsCnt);

        }

    test.Printf(_L("\n\r"));

    return nRes;

}

#define TESTL(con) TestL(con,r,__LINE__)

void TestL(TBool aCondition, TInt aError, TInt aLine = 0)

    {

    if (!aCondition)

        {

        RDebug::Printf("Test fail at line: %d with error code %d",aLine, aError);

        RestoreEnv();

        }

    test(aCondition);

    }

//-------------------------------------------------------------

void RestoreEnv()

    {

    test.Printf(_L("RestoreEnv()\n"));

    TInt r = TheFs.DismountExtension(KExtName, gDrive);

    r = TheFs.RemoveExtension(KExtName);

    if(gExtExists)      // remount existing secondary extension

        {

        test(TheFs.MountExtension(gExtName, gDrive)==KErrNone);

        }

    //-- We need a full format, because quick format preserves bad sectors marked in FAT

    r = FormatFatDrive(TheFs, gDrive, EFalse);

    }

//-------------------------------------------------------------

// Remount drive with FAT test extension

TBool PrepareMount()

    {

    test.Printf(_L("PrepareMountL(), drive:%d \n"),gDrive);

    TInt r = TheFs.AddExtension(KExtName);

    r = TheFs.ExtensionName(gExtName,gDrive,0);

    if (r == KErrNone)              // an extension already exists -> dismount it

        {

        test.Printf(_L("Drive %d has extension, attempt dismounting it\n"),gDrive);

        r=TheFs.DismountExtension(gExtName,gDrive);

        if(r==KErrAccessDenied)     // primary extension

            {

            test.Printf(_L("Drive %d has primary extension, skip\n"),gDrive);

            test(TheFs.RemoveExtension(KExtName) == KErrNone);

            return EFalse;

            }

        gExtExists=ETrue;

        }

    r = TheFs.MountExtension(KExtName, gDrive);

    if (r != KErrNone)

        test(TheFs.RemoveExtension(KExtName) == KErrNone);

    return ETrue;

    }

//-------------------------------------------------------------

void MarkClustersL()

    {

    TInt size = sizeof(gBadList) / sizeof(TInt);

    for (TInt i=0; i<size; i++)

        {

        TInt r = TheFs.ControlIo(gDrive,CFatTestProxyDrive::EMark,(TAny*)gBadList[i],NULL);

        TESTL(r == KErrNone);

        }

    }

//-------------------------------------------------------------

/**

    Create 3 empty files on the volume

*/

void CreateFiles()

    {

    TInt r;

    RFile file;

    TBuf<10> fileName01;

    fileName01.Append(_L("?:\\file01"));

    fileName01[0] = (TUint16)gDriveToTest;

    r = file.Create(TheFs, fileName01, EFileWrite);

    TESTL(r==KErrNone||r==KErrAlreadyExists);

    file.Close();

    TBuf<10> fileName02;

    fileName02.Append(_L("?:\\file02"));

    fileName02[0] = (TUint16)gDriveToTest;

    r = file.Create(TheFs, fileName02, EFileWrite);

    TESTL(r==KErrNone||r==KErrAlreadyExists);

    file.Close();

    TBuf<10> fileName03;

    fileName03.Append(_L("?:\\file03"));

    fileName03[0] = (TUint16)gDriveToTest;

    r = file.Create(TheFs, fileName03, EFileWrite);

    TESTL(r==KErrNone||r==KErrAlreadyExists);

    file.Close();

    }

//-------------------------------------------------------------

/**

    Read/Write to the file with damaged clusters

*/

void DoTestReadWriteL()

    {

    CreateFiles();

    // Get disk mount information

    TPckgBuf<TInt> dataPositionBuf;

    TPckgBuf<TInt> sectorsPerClusterBuf;

    TInt r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::EGetDataPosition,dataPositionBuf);

    TESTL(r==KErrNone);

    //-- media position of the 1st data sector on the volume.

    //-- for FAT32 this is the 2nd cluster of the data ares, because 1st belongs to the root dir.

    const TInt dataPosition = dataPositionBuf();

    r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::ESectorsPerCluster,sectorsPerClusterBuf);

    TESTL(r==KErrNone);

    const TInt sectorsPerCluster = sectorsPerClusterBuf(); //-- FAT sectors per cluster

    // Calculate file data sectors

    // For FAT32, first data sector falls under root directory, and current FAT32

    // file system implementation does not take care of handling bad sectors in

    // root directory so changing start sector to be the start sector of the file,

    // instead of first data sector.

    TInt f01_StartSector;

    if(Is_Fat32(TheFs,gDrive))

    {

        f01_StartSector = (dataPosition >> KDefaultSectorLog2);

        test.Printf(_L("FAT32, dataPosition: %d, sec:%d, spc:%d\n"), dataPosition, f01_StartSector, sectorsPerCluster);

    }

    else

    {

        f01_StartSector = (dataPosition >> KDefaultSectorLog2);

        test.Printf(_L("dataPosition: %d, sec:%d, spc:%d\n"), dataPosition, f01_StartSector, sectorsPerCluster);

    }

    //TInt f01end = f01beg + sectorsPerCluster - 1;

    //TInt f02beg = f01end + 1;

    //TInt f02end = f02beg + sectorsPerCluster - 1;

    //TInt f03beg = f02end + 1;

    //TInt f03end = f03beg + sectorsPerCluster - 1;

    test.Next(_L("Test file write"));

    //-- mark the sector that file01 starts with as bad

    r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::EMark,(TAny*)(f01_StartSector),NULL);

    TESTL(r==KErrNone);

    TBuf<10> fileName01;

    fileName01.Append(_L("?:\\file01"));

    fileName01[0] = (TUint16)gDriveToTest;

    RFile file;

    //-- write to the file with bad sector

    r = file.Open(TheFs, fileName01, EFileWrite);

    TESTL(r==KErrNone);

    TInt size = 2 * sectorsPerCluster * KDefaultSectorSize;   //-- 2 clusters

    RBuf8 writeBuf01;

    r = writeBuf01.CreateMax(size);

    TESTL(r == KErrNone);

    r = file.Write(writeBuf01, size);

    TESTL(r==KErrNone);

    file.Close();

    test.Next(_L("Test file read"));

    //-- unmark bas sector

    r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::EUnmark,(TAny*)(f01_StartSector),NULL);

    TESTL(r==KErrNone);

    //-- mark the 2nd cluster in the file as bad

    r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::EMark,(TAny*)(f01_StartSector+sectorsPerCluster),NULL);

    TESTL(r==KErrNone);

    r = file.Open(TheFs, fileName01, EFileRead);

    TESTL(r==KErrNone);

    //-- read the file from "corrupted" media

    r = file.Read(writeBuf01, size);

    TESTL(r==KErrCorrupt); //-- the file must be corrupted

    file.Close();

    r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::EUnmarkAll, NULL, NULL);

    TESTL(r==KErrNone);

    writeBuf01.Close();

    }

//-------------------------------------------------------------------------------------------------------

/**

    Suggest FAT volume metrics by volume size in sectors. Pay attention to the KMaxSectorsPerCluster constant.

    @param  aVolSizeInSectors   FAT volume size in sectors

    @param  apSectPerCluster    on return here will be suggested number of sectors per cluster

    @param  apRootDirEntries    on return here will be suggested max. number of root dir. entries.

*/

void SuggestVolMetrics(TUint aVolSizeInSectors, TUint16 *apSectPerCluster, TUint *apRootDirEntries=NULL)

{

    const TUint16  KMaxSectorsPerCluster = 32; //-- maximal number sectors per cluster to use

          TUint16  sectorsPerCluster;

          TUint    rootDirEntries;

    //-- suggest Sector per Cluster value, most suitable for the given volume size. (taken from CFatFormatCB::InitFormatDataForFixedSizeDiskUser(...))

    if (aVolSizeInSectors < 4096) // < 2MB

        {

        sectorsPerCluster = 1;

        rootDirEntries    = 128;

        }

    else if (aVolSizeInSectors < 8192) // < 4MB

        {

        sectorsPerCluster = Min(KMaxSectorsPerCluster, 2);

        rootDirEntries = 256;

        }

    else if (aVolSizeInSectors < 32768) // < 16MB

        {

        sectorsPerCluster = Min(KMaxSectorsPerCluster, 4);

        rootDirEntries = 512;

        }

    else if (aVolSizeInSectors < 1048576) // < 512MB

        {

        sectorsPerCluster = Min(KMaxSectorsPerCluster, 8);

        rootDirEntries = 512;

        }

    else // FAT32

        {

        sectorsPerCluster = KMaxSectorsPerCluster;

        rootDirEntries = 512;

        }

    //---------------------------------------

    if(apSectPerCluster)

        *apSectPerCluster = sectorsPerCluster;

    if(apRootDirEntries)

        *apRootDirEntries = rootDirEntries;

}

//-------------------------------------------------------------

/**

    Test user-specific FAT format. FAT type 12,16 or 32 will depend on disk size.

    @param  aQuick if not 0 a quick format will be performed.

*/

void DoTestUserFormatL(TBool aQuick, TBool aMark)

    {

    const TUint32   KKiloByte = 1024;

    TInt r;

    //-- obtain current FAT volume metrics

    TVolumeInfo volInfo;

    r = TheFs.Volume(volInfo, gDrive);

    TESTL(r == KErrNone);

    const TInt64    volSize = volInfo.iSize; //-- volume size in bytes

    const TUint     volSizeInSectors = TUint(volSize >> KDefaultSectorLog2); //-- sectors per volume

    TUint16   sectorsPerCluster=0;

    TUint     rootDirEntries = 0;

    TUint     fatType = 0;

    //-- roughly suggest FAT type for this volume, if FAT type is incorrect, RFormat will fail.

    //-- suggest Sector per Cluster value, most suitable for this volume size  (taken from CFatFormatCB::InitFormatDataForFixedSizeDiskUser(...))

    SuggestVolMetrics(volSizeInSectors, &sectorsPerCluster, &rootDirEntries);

    const TUint totVolClusterCnt = volSizeInSectors / sectorsPerCluster; //-- total clusters per this volume

    //-- doesn't count here FAT size, RootDir size and reserved sectors. For rough estimations only, otherwise

    //-- it will be far too complicated.

    const TUint dataClusterCnt = totVolClusterCnt;

    //-- magic. see FAT specs for details.

    if(dataClusterCnt < 4085)

        fatType = TLDFormatInfo::EFB12;

    else if(dataClusterCnt < 65525)

        fatType = TLDFormatInfo::EFB16;

    else

        fatType = TLDFormatInfo::EFB32;

    test.Printf(_L("Formatting drive %C:, size=%uKB, SecPerClust=%u, FAT%d\n"), ('A'+gDrive), (TUint32)(volSize/KKiloByte), sectorsPerCluster, fatType);

    //-- formatting the volume

    TInt formatCnt;

    TLDFormatInfo formatInfo;

    formatInfo.iSectorsPerCluster = sectorsPerCluster;

    formatInfo.iFATBits = (TLDFormatInfo::TFATBits)fatType;

    TSpecialFormatInfoBuf formatInfoBuf(formatInfo);

    RFormat formatUser;

    if (aQuick)

        {

        r = formatUser.Open(TheFs, gDriveName, ESpecialFormat|EQuickFormat, formatCnt, formatInfoBuf);

        TESTL(r == KErrNone);

        }

    else

        {

        r = formatUser.Open(TheFs, gDriveName, ESpecialFormat, formatCnt, formatInfoBuf);

        TESTL(r == KErrNone);

        }

    if(aMark)

        {

        MarkClustersL();

        }

    r = DoFormatSteps(formatUser, formatCnt);

    TESTL(r == KErrNone || r == KErrNotSupported);

    formatUser.Close();

    if (r == KErrNotSupported)

        {

        test.Printf(_L("Media does not support ESpecialFormat"));

        return;

        }

    //-- format has finished, Check format validity

    TPckgBuf<TInt> sbuf;

    r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::ESectorsPerCluster, sbuf);

    TESTL(r==KErrNone);

    const TInt resSectorsPerCluster = sbuf();

    TPckgBuf<TInt64> sizebuf;

    r = TheFs.ControlIo(gDrive, CTestProxyDrive::EDiskSize, sizebuf);

    TESTL(r==KErrNone);

    const TInt64 resVolSize = sizebuf();

    //-- Check fat type

    TPckgBuf<TInt> tbuf;

    r = TheFs.ControlIo(gDrive, CFatTestProxyDrive::EFatType, tbuf);

    TESTL(r==KErrNone);

    const TUint resFatType = tbuf();

    test.Printf(_L("Format result:, size=%uKB, SecPerClust=%u, FAT%d\n"), (TUint32)(resVolSize/KKiloByte), resSectorsPerCluster, resFatType);

    TESTL(resFatType == fatType);

    //-- user-defined format CFatFormatCB::InitFormatDataForFixedSizeDiskUser(TInt aDiskSizeInSectors)

    //-- can decide decides how many SectorsPerCluster will be on the volume. As the result, requested and resulted values can be different.

    TESTL(resSectorsPerCluster == sectorsPerCluster);

    //-- check whole drive

    test.Next(_L("Check Disk"));

    r = TheFs.CheckDisk(gDriveName);

    TESTL(r==KErrNone);

    }

//-------------------------------------------------------------

/** Randomly generate several sector numbers in FAT data area, which will be marked as bad. */

static void CreateBadList()

{

    static TInt64 rndSeed = Math::Random();

    const TInt size = sizeof(gBadList) / sizeof(TInt);

    //const TUint32 dataStartSector = BootSector.FirstFreeSector(); //-- 1st sector number of the data area (after the root directory for fat12/16)

    //-- 1st sector number of the data area.

    //-- for fat12/16 it will be 1st sector after the root directory

    //-- for fat32 it will be the 1st sector of the second cluster after the root directory. At present we don't handle the 1st bad cluster of the root dir.

    TUint32 dataStartSector;

    if(BootSector.FatType() == EFat32)

    {

        dataStartSector = BootSector.RootDirStartSector() + 1*BootSector.SectorsPerCluster();

    }

    else

    {

        dataStartSector = BootSector.FirstDataSector();

    }

    test.Printf(_L("data start sector:%d, total sectors:%d\n"), dataStartSector, BootSector.VolumeTotalSectorNumber());

     //-- randomly generate bad sectors numbers in the FAT volume data area

    for(TInt i = 0; i<size; ++i)

     {

        const TUint32 rand = ((TUint32)Math::Rand(rndSeed)) % (BootSector.VolumeTotalSectorNumber() - dataStartSector);

        const TUint32 sectNum = dataStartSector + rand;

        gBadList[i] = sectNum;

        test.Printf(_L("Value of gBadList[%d] is %d\n"), i, gBadList[i]);

     }

}

//-------------------------------------------------------------

/**

    Read and validate the boot sector

*/

static void ReadBootSector()

{

    test.Printf(_L("Reading Boot sector...\n"));

    TInt nRes = ReadBootSector(TheFs, gDrive, KBootSectorNum << KDefaultSectorLog2, BootSector);

    test(nRes == KErrNone);

    if(!BootSector.IsValid())

    {

        test.Printf(_L("The boot sector is invalid! dump:\n"));

        BootSector.PrintDebugInfo();

        test(0);

    }

}

//

// Write version number to disk using raw disk write

// For FAT 32 the version number is written to the backup boot sector as well.

//

void WriteVersionNumber()