// Copyright (c) 1996-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:

// @file

// various FAT test utilities 

// 

//

#include "fat_utils.h"

using namespace Fat_Test_Utils;

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

//-- define this macro if it is necessarily to exclude all stuff that uses RFs, consoles etc.

//-- may be useful if this code is used for file server extensions. mmp file is a good place to define this macro.

#ifndef FAT_UTILS_LEAN_AND_MEAN

#include <e32cons.h>

#include <e32math.h>

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

/**

    Format FAT volume

    @param  aFs             reference to the FS session

    @param  aDrive          drive number

    @param  aQuickFormat    if True, a quick format will be performed. otherwise - full

    @param  apFmtParams     pointer to the optional format parameters. if NULL, it means tha no options specified

    @param  aForceErase     if True, use media force erase.

    @return system-wide error codes.

*/

TInt Fat_Test_Utils::FormatFatDrive(RFs &aFs, TInt aDrive, TBool aQuickFormat, const TFatFormatParam* apFmtParams/*=NULL*/, TBool aForceErase /*=EFalse*/)

{

    TPtrC fmtTypeName = (aQuickFormat ? _L("Quick") : _L("Full"));

    DoPrintf(_L("~ Fat_Test_Utils::FormatFatDrive() drv:%d, type:%S\n"),aDrive, &fmtTypeName);

    ASSERT(aDrive >= EDriveA && aDrive <= EDriveZ);

    RFormat format;

    TUint   fmtMode=0;

    TInt    fmtCnt=0;

    TInt    prevCnt;

    TInt    nRes;

    if(aQuickFormat) 

        fmtMode |= EQuickFormat;

    if(aForceErase)

        fmtMode |= EForceErase;

    TBuf<10> drvName;

    drvName.Format(_L("%C:"),'A'+aDrive);

    if(!apFmtParams)

    {//-- no format parameters specified

        //DoPrintf(_L("~ Format parameters - not specified\n"));

        nRes = format.Open(aFs, drvName, fmtMode, fmtCnt);

        if(nRes!=KErrNone)

            goto Fail;

    }

    else

    {//-- some extra parameters specified, use special format

        fmtMode |= ESpecialFormat;

        TLDFormatInfo formatInfo;

        TBuf<100> buf;

        buf.Copy(_L("~ Format parameters: "));

        if(apFmtParams->iFatType)

        {//-- FAT type is specified

            buf.AppendFormat(_L("FAT%d"), apFmtParams->iFatType);

            formatInfo.iFATBits = (TLDFormatInfo::TFATBits)apFmtParams->iFatType;

        }

        const TUint16 spc = (TUint16)apFmtParams->iSecPerCluster;

        if(spc)

        {//-- sectors per cluster value is specified

            buf.AppendFormat(_L(", spc:%d"), spc);

            formatInfo.iSectorsPerCluster = spc;

        }

        const TUint16 rsvdSec = (TUint16)apFmtParams->iReservedSectors;

        if(rsvdSec)

        {//-- reserved sectors numer is specified

            buf.AppendFormat(_L(", rsvdSec:%d"), rsvdSec);

            formatInfo.iReservedSectors = rsvdSec;

        }

        buf.Append(_L("\n"));

        DoPrintf(buf);

        TSpecialFormatInfoBuf formatInfoBuf(formatInfo);

        nRes = format.Open(aFs, drvName, fmtMode, fmtCnt, formatInfoBuf);

        if(nRes!=KErrNone)

            goto Fail;

    }

    //-- do format steps

    prevCnt=fmtCnt;

    while(fmtCnt)

    {

        nRes = format.Next(fmtCnt);

        if(nRes!=KErrNone)

            goto Fail;

        if(fmtCnt != prevCnt)

        {

            DoPrintf(_L("."));

            prevCnt = fmtCnt;

        }

    }

    //-- formatting has finished

    DoPrintf(_L("\n"));

    format.Close();

    return KErrNone;

   Fail:

    format.Close();

    DoPrintf(_L("~ Fat_Test_Utils::FormatFatDrive() failed! code:%d\n"), nRes);

    return nRes;

}

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

/**

    Read FAT FSInfo sector via RRawDisk interface.

    @param  aFs         reference to the FS session

    @param  aDrive      drive number

    @param  aMediaPos   media position (0 for the main boot sector)

    @param  aFsInfo     where to read data

    @return standard error codes

*/

TInt Fat_Test_Utils::ReadFSInfoSector(RFs &aFs, TInt aDrive, TInt64 aMediaPos, TFSInfo& aFsInfo)

{

    DoPrintf(_L("~ Fat_Test_Utils::ReadFSInfoSector() drv:%d, pos:0x%x\n"),aDrive, (TUint32)aMediaPos);   

    TInt nRes = KErrNone;

    TBuf8<KSizeOfFSInfo> fsInfoSecBuf(KSizeOfFSInfo);

    TRAP(nRes, DoMediaRawReadL(aFs, aDrive, aMediaPos, fsInfoSecBuf.Size(), fsInfoSecBuf));

    if(nRes == KErrNone)

    {//-- take FSInfo data from the buffer

        aFsInfo.Internalize(fsInfoSecBuf);

    }

    return nRes;

}

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

/**

    Write FAT FSInfo sector via RRawDisk interface.

    @param  aFs         reference to the FS session

    @param  aDrive      drive number

    @param  aMediaPos   media position (0 for the main boot sector)

    @param  aFsInfo     data to write

    @return standard error codes

*/

TInt Fat_Test_Utils::WriteFSInfoSector(RFs &aFs, TInt aDrive, TInt64 aMediaPos, const TFSInfo& aFsInfo)

{

    DoPrintf(_L("~ Fat_Test_Utils::WriteFSInfoSector() drv:%d, pos:0x%x\n"),aDrive, (TUint32)aMediaPos);   

    TInt nRes = KErrNone;

    TBuf8<KSizeOfFSInfo> fsInfoSecBuf;

    //-- put data to the sector buffer

    aFsInfo.Externalize(fsInfoSecBuf);

    TRAP(nRes, DoMediaRawWriteL(aFs, aDrive, aMediaPos, fsInfoSecBuf))

    return nRes;

}

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

/**

    Read FAT boot sector via RRawDisk interface.

    @param  aFs         reference to the FS session

    @param  aDrive      drive number

    @param  aMediaPos   media position (0 for the main boot sector)

    @param  aBootSector where to read data

    @return standard error codes

*/

TInt  Fat_Test_Utils::ReadBootSector(RFs &aFs, TInt aDrive, TInt64 aMediaPos, TFatBootSector& aBootSector)

{

    DoPrintf(_L("~ Fat_Test_Utils::ReadBootSector() drv:%d, pos:0x%x\n"),aDrive, (TUint32)aMediaPos);   

    TInt nRes = KErrNone;

    TBuf8<KSizeOfFatBootSector> bootSecBuf(KSizeOfFatBootSector);

    TRAP(nRes, DoMediaRawReadL(aFs, aDrive, aMediaPos, bootSecBuf.Size(), bootSecBuf));

    if(nRes==KErrNone)

    {//-- initialise TFatBootSector object

        aBootSector.Internalize(bootSecBuf);

    }

    return nRes;

}

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

/**

    Write FAT boot sector via RRawDisk interface.

    @param  aFs         reference to the FS session

    @param  aDrive      drive number

    @param  aMediaPos   media position (0 for the main boot sector)

    @param  aBootSector data to write

    @return standard error codes

*/

TInt  Fat_Test_Utils::WriteBootSector(RFs &aFs, TInt aDrive, TInt64 aMediaPos, const TFatBootSector& aBootSector)

{

    DoPrintf(_L("~ Fat_Test_Utils::WriteBootSector() drv:%d, pos:0x%x\n"),aDrive, (TUint32)aMediaPos);   

    TBuf8<KDefaultSectorSize> bootSecBuf(KDefaultSectorSize);

    //-- externalize boot sector to the data buffer

    bootSecBuf.FillZ();

    aBootSector.Externalize(bootSecBuf); 

    //-- put a boot sector signature to the last 2 bytes

    bootSecBuf[KDefaultSectorSize-2] = 0x55;

    bootSecBuf[KDefaultSectorSize-1] = 0xaa;

    //-- write boot sector data to the media

    TInt nRes=KErrNone;

    TRAP(nRes, DoMediaRawWriteL(aFs, aDrive, aMediaPos, bootSecBuf));

    return nRes;

}

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

/** 

    Obtain FAT type for the given drive 

    @return TFatType enum values. if aDrive has not FAT FS, EInvalid value is returned

*/

TFatType Fat_Test_Utils::GetFatType(RFs &aFs, TInt aDrive)

{

    if(Is_Fat16(aFs, aDrive))

        return EFat16;

    else if(Is_Fat32(aFs, aDrive))

        return EFat32;

    else if(Is_Fat12(aFs, aDrive))

        return EFat12;

    return EInvalid;

}

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

#endif //FAT_UTILS_LEAN_AND_MEAN

TFatFormatParam::TFatFormatParam()

{

    iFatType = EInvalid;

    iSecPerCluster = 0;

    iReservedSectors = 0;

}

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

TFatBootSector::TFatBootSector()

{

    Initialise();

}

/** initialises the boot sector data */

void TFatBootSector::Initialise()

{

    Mem::FillZ(this, sizeof(TFatBootSector));

}

TBool TFatBootSector::operator==(const TFatBootSector& aRhs)

{

    ASSERT(&aRhs != this);

    if(&aRhs == this)

        return ETrue; //-- comparing with itself

    return  (Mem::Compare((TUint8*)this, sizeof(TFatBootSector), (TUint8*)&aRhs, sizeof(TFatBootSector)) == 0);

}

/**

    @return ETrue if the boot sector contents seems to be valid

*/

TBool TFatBootSector::IsValid() const

{

    const TFatType fatType = FatType(); //-- it will check SectorsPerCluster etc.

    if(fatType == EInvalid || ReservedSectors() < 1 || NumberOfFats() < 1)

        goto Invalid;

    if(fatType == EFat32)

    {

        if(VersionNumber()!= 0 || FatSectors()!=0 || FatSectors32()<1 || RootClusterNum()<(TUint32)KFatFirstSearchCluser ||

           TotalSectors()!=0 || HugeSectors() <5 || RootDirEntries() !=0)

        {

            goto Invalid; //-- these values are not compliant with FAT specs

        }

    }

    else //-- FAT12/16

    {

        if(TotalSectors() >0 && HugeSectors() >0 )

            goto Invalid; //-- values clash

        const TUint32 totSectors = Max(TotalSectors(), HugeSectors());

        const TUint32 rootDirStartSec =  ReservedSectors() + FatSectors()*NumberOfFats(); //-- root directory start sector

        if(FatSectors() < 1 || rootDirStartSec < 3 || RootDirEntries() < 1 || totSectors < 5)

            goto Invalid; //-- these values are not compliant with FAT specs

    }

    return ETrue;

  Invalid:

    DoPrintf(_L("~ TFatBootSector::IsValid() failed!\n"));

    return EFalse;

}

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

/**

    Initialize boot sector object from the given bufer. Does not validate the data.

    @param  aBuf buffer with data.

*/

void TFatBootSector::Internalize(const TDesC8& aBuf)

{

    ASSERT(aBuf.Size() >= KSizeOfFatBootSector);

    Initialise();

    TInt pos=0;

    Mem::Copy(&iJumpInstruction, &aBuf[pos],3);     pos+=3; // 0    TUint8 iJumpInstruction[3]

    Mem::Copy(&iVendorId,&aBuf[pos],KVendorIdSize); pos+=KVendorIdSize; // 3    TUint8 iVendorId[KVendorIdSize]

    Mem::Copy(&iBytesPerSector,&aBuf[pos],2);       pos+=2; // 11   TUint16 iBytesPerSector

    Mem::Copy(&iSectorsPerCluster,&aBuf[pos],1);    pos+=1; // 13   TUint8 iSectorsPerCluster   

    Mem::Copy(&iReservedSectors,&aBuf[pos],2);      pos+=2; // 14   TUint16 iReservedSectors

    Mem::Copy(&iNumberOfFats,&aBuf[pos],1);         pos+=1; // 16   TUint8 iNumberOfFats

    Mem::Copy(&iRootDirEntries,&aBuf[pos],2);       pos+=2; // 17   TUint16 iRootDirEntries

    Mem::Copy(&iTotalSectors,&aBuf[pos],2);         pos+=2; // 19   TUint16 iTotalSectors

    Mem::Copy(&iMediaDescriptor,&aBuf[pos],1);      pos+=1; // 21   TUint8 iMediaDescriptor

    Mem::Copy(&iFatSectors,&aBuf[pos],2);           pos+=2; // 22   TUint16 iFatSectors

    Mem::Copy(&iSectorsPerTrack,&aBuf[pos],2);      pos+=2; // 24   TUint16 iSectorsPerTrack

    Mem::Copy(&iNumberOfHeads,&aBuf[pos],2);        pos+=2; // 26   TUint16 iNumberOfHeads

    Mem::Copy(&iHiddenSectors,&aBuf[pos],4);        pos+=4; // 28   TUint32 iHiddenSectors

    Mem::Copy(&iHugeSectors,&aBuf[pos],4);          pos+=4; // 32   TUint32 iHugeSectors

    if(RootDirEntries() == 0) //-- we have FAT32 volume

    {

        Mem::Copy(&iFatSectors32, &aBuf[pos],4);    pos+=4; // 36 TUint32 iFatSectors32     

        Mem::Copy(&iFATFlags, &aBuf[pos],2);        pos+=2; // 40 TUint16 iFATFlags

        Mem::Copy(&iVersionNumber, &aBuf[pos],2);   pos+=2; // 42 TUint16 iVersionNumber

        Mem::Copy(&iRootClusterNum, &aBuf[pos],4);  pos+=4; // 44 TUint32 iRootClusterNum

        Mem::Copy(&iFSInfoSectorNum, &aBuf[pos],2); pos+=2; // 48 TUint16 iFSInfoSectorNum

        Mem::Copy(&iBkBootRecSector, &aBuf[pos],2);         // 50 TUint16 iBkBootRecSector

        pos+=(2+12);    //extra 12 for the reserved bytes   

    }

    Mem::Copy(&iPhysicalDriveNumber,&aBuf[pos],1);  pos+=1;// 36|64 TUint8 iPhysicalDriveNumber

    Mem::Copy(&iReserved,&aBuf[pos],1);             pos+=1;// 37|65 TUint8 iReserved

    Mem::Copy(&iExtendedBootSignature,&aBuf[pos],1);pos+=1;// 38|66 TUint8 iExtendedBootSignature

    Mem::Copy(&iUniqueID,&aBuf[pos],4);             pos+=4;// 39|67 TUint32 iUniqueID

    Mem::Copy(&iVolumeLabel,&aBuf[pos],KVolumeLabelSize);  // 43|71 TUint8 iVolumeLabel[KVolumeLabelSize]

    pos+=KVolumeLabelSize;

    // 54|82    TUint8 iFileSysType[KFileSysTypeSize]

    ASSERT(aBuf.Size() >= pos+KFileSysTypeSize);

    Mem::Copy(&iFileSysType,&aBuf[pos],KFileSysTypeSize);

}

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

/**

    Externalize boot sector object to the given data buffer.

    @param  aBuf buffer to externalize.

*/

void TFatBootSector::Externalize(TDes8& aBuf) const

{

    ASSERT(aBuf.MaxSize() >= KSizeOfFatBootSector);

    if(aBuf.Size() < KSizeOfFatBootSector)

        aBuf.SetLength(KSizeOfFatBootSector);

    TInt pos=0;

    Mem::Copy(&aBuf[pos],&iJumpInstruction,3);      pos+=3;

    Mem::Copy(&aBuf[pos],&iVendorId,KVendorIdSize); pos+=8;

    Mem::Copy(&aBuf[pos],&iBytesPerSector,2);       pos+=2;

    Mem::Copy(&aBuf[pos],&iSectorsPerCluster,1);    pos+=1;

    Mem::Copy(&aBuf[pos],&iReservedSectors,2);      pos+=2;

    Mem::Copy(&aBuf[pos],&iNumberOfFats,1);         pos+=1;

    Mem::Copy(&aBuf[pos],&iRootDirEntries,2);       pos+=2;

    Mem::Copy(&aBuf[pos],&iTotalSectors,2);         pos+=2;

    Mem::Copy(&aBuf[pos],&iMediaDescriptor,1);      pos+=1;

    Mem::Copy(&aBuf[pos],&iFatSectors,2);           pos+=2;

    Mem::Copy(&aBuf[pos],&iSectorsPerTrack,2);      pos+=2;

    Mem::Copy(&aBuf[pos],&iNumberOfHeads,2);        pos+=2;

    Mem::Copy(&aBuf[pos],&iHiddenSectors,4);        pos+=4;

    Mem::Copy(&aBuf[pos],&iHugeSectors,4);          pos+=4;

    if(iFatSectors == 0)    

        {

        Mem::Copy(&aBuf[pos], &iFatSectors32,4);    pos+=4;

        Mem::Copy(&aBuf[pos], &iFATFlags, 2);       pos+=2;

        Mem::Copy(&aBuf[pos], &iVersionNumber, 2);  pos+=2;

        Mem::Copy(&aBuf[pos], &iRootClusterNum, 4); pos+=4;

        Mem::Copy(&aBuf[pos], &iFSInfoSectorNum, 2);pos+=2;

        Mem::Copy(&aBuf[pos], &iBkBootRecSector, 2);pos+=2;

        //extra 12 for the reserved bytes   

        ASSERT(aBuf.Size() >= pos+12);

        Mem::FillZ(&aBuf[pos],12);

        pos+=12;

        }

    Mem::Copy(&aBuf[pos],&iPhysicalDriveNumber,1);  pos+=1;

    Mem::FillZ(&aBuf[pos],1);                       pos+=1;

    Mem::Copy(&aBuf[pos],&iExtendedBootSignature,1);pos+=1;

    Mem::Copy(&aBuf[pos],&iUniqueID,4);             pos+=4;

    Mem::Copy(&aBuf[pos],&iVolumeLabel,KVolumeLabelSize); 

    pos+=KVolumeLabelSize;

    ASSERT(aBuf.MaxSize() >= pos+KFileSysTypeSize);

    Mem::Copy(&aBuf[pos],&iFileSysType,KFileSysTypeSize);

}

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

/** replaces all non-printable characters in a buffer with spaces */

static void FixDes(TDes& aDes)

{

    for(TInt i=0; i< aDes.Length(); ++i)

    {

        TChar ch=aDes[i];

        if(!ch.IsPrint())

            aDes[i]=' ';    

    }

}

/** 

    Print out the boot sector info.

*/

void TFatBootSector::PrintDebugInfo() const

{

    TBuf<40> buf;

    DoPrintf(_L("======== BootSector info: =======\n"));

    buf.Copy(FileSysType()); FixDes(buf);    

    DoPrintf(_L("FAT type:%S\n"),&buf);

    buf.Copy(VendorId()); FixDes(buf);

    DoPrintf(_L("Vendor ID:%S\n"),&buf);

    DoPrintf(_L("BytesPerSector: %d\n"),BytesPerSector());

    DoPrintf(_L("SectorsPerCluster: %d\n"),SectorsPerCluster());

    DoPrintf(_L("ReservedSectors: %d\n"),ReservedSectors());

    DoPrintf(_L("NumberOfFats: %d\n"),NumberOfFats());

    DoPrintf(_L("RootDirEntries: %d\n"),RootDirEntries());

    DoPrintf(_L("Total Sectors: %d\n"),TotalSectors());

    DoPrintf(_L("MediaDescriptor: 0x%x\n"),MediaDescriptor());

    DoPrintf(_L("FatSectors: %d\n"),FatSectors());

    DoPrintf(_L("SectorsPerTrack: %d\n"),SectorsPerTrack());

    DoPrintf(_L("NumberOfHeads: %d\n"),NumberOfHeads());

    DoPrintf(_L("HugeSectors: %d\n"),HugeSectors());

    DoPrintf(_L("Fat32 Sectors: %d\n"),FatSectors32());

    DoPrintf(_L("Fat32 Flags: %d\n"),FATFlags());

    DoPrintf(_L("Fat32 Version Number: %d\n"),VersionNumber());

    DoPrintf(_L("Root Cluster Number: %d\n"),RootClusterNum());

    DoPrintf(_L("FSInfo Sector Number: %d\n"),FSInfoSectorNum());

    DoPrintf(_L("Backup Boot Rec Sector Number: %d\n"),BkBootRecSector());

    DoPrintf(_L("PhysicalDriveNumber:%d\n"),PhysicalDriveNumber());

    DoPrintf(_L("ExtendedBootSignature: %d\n"),ExtendedBootSignature());

    DoPrintf(_L("UniqueID: 0x%x\n"),UniqueID());

    buf.Copy(VolumeLabel()); FixDes(buf);

    DoPrintf(_L("VolumeLabel:%S\n"),&buf);

    DoPrintf(_L("=============================\n"));

}

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

/**

    Determine FAT type according to the information from boot sector, see FAT32 specs.

    @return  FAT type. 

*/

TFatType TFatBootSector::FatType(void) const

    {

    //-- check iBytesPerSector validity; it shall be one of: 512,1024,2048,4096

    if(!IsPowerOf2(iBytesPerSector) || iBytesPerSector < 512 ||  iBytesPerSector > 4096)

        return EInvalid; //-- invalid iBytesPerSector value

    //-- check iSectorsPerCluster validity, it shall be one of: 1,2,4,8...128

    if(!IsPowerOf2(iSectorsPerCluster) || iSectorsPerCluster > 128)

        return EInvalid; //-- invalid iSectorsPerCluster value

    const TUint32 rootDirSectors = (iRootDirEntries*KSizeOfFatDirEntry + (iBytesPerSector-1)) / iBytesPerSector;

    const TUint32 fatSz = iFatSectors ? iFatSectors : iFatSectors32;

    const TUint32 totSec = iTotalSectors ? iTotalSectors : iHugeSectors;

    const TUint32 dataSec = totSec - (iReservedSectors + (iNumberOfFats * fatSz) + rootDirSectors);

    const TUint32 clusterCnt = dataSec / iSectorsPerCluster;

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

    if(clusterCnt < 4085)

        return EFat12;

    else if(clusterCnt < 65525)

        return EFat16;

    else

        return EFat32;

    }

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

/** Returns Sectors in Fat table for 32 bit volume */

TUint32 TFatBootSector::FatSectors32() const	

{return iFatSectors32;}

/** Fat flags */

TUint16 TFatBootSector::FATFlags() const		

{return iFATFlags;}

/** Version number of the file system */

TUint16 TFatBootSector::VersionNumber() const		

{return iVersionNumber;}

/** Cluster number of the root directory */

TUint32 TFatBootSector::RootClusterNum() const	

{return iRootClusterNum;}

/** Sector number containing the FSIInfo structure */

TUint16 TFatBootSector::FSInfoSectorNum() const

{return iFSInfoSectorNum;}

/** Backup boot sector */

TUint16 TFatBootSector::BkBootRecSector() const

{return iBkBootRecSector;}

/** Sets the number of sectors in Fat table for 32 bit volume */

void TFatBootSector::SetFatSectors32(TUint32	aFatSectors32)

{iFatSectors32 = aFatSectors32;}

/** Sets the Fat flags */

void TFatBootSector::SetFATFlags(TUint16 aFATFlags)

{iFATFlags = aFATFlags;}

/** Sets the version number of the file system */

void TFatBootSector::SetVersionNumber(TUint16 aVersionNumber)

{iVersionNumber = aVersionNumber;}

/** Sets the cluster number of the root directory */

void TFatBootSector::SetRootClusterNum(TUint32 aRootClusterNum)	

{iRootClusterNum = aRootClusterNum;}

/** Set the sector number containing the FSIInfo structure */

void TFatBootSector::SetFSInfoSectorNum(TUint16 aFSInfoSectorNum)

{iFSInfoSectorNum = aFSInfoSectorNum;}

/** Set the backup boot sector */

void TFatBootSector::SetBkBootRecSector(TUint16 aBkBootRecSector)

{iBkBootRecSector = aBkBootRecSector;}	

/** Returns the vendor ID of the file system that formatted the volume */

const TPtrC8 TFatBootSector::VendorId() const

{return TPtrC8(iVendorId,KVendorIdSize);}

/** Return the bytes per sector */

TUint16 TFatBootSector::BytesPerSector() const

{return iBytesPerSector;}

/** Returns the sectors per cluster ratio */

TInt TFatBootSector::SectorsPerCluster() const

{return iSectorsPerCluster;}

/** Returns the number of reserved sectors on the volume */

TInt TFatBootSector::ReservedSectors() const

{return iReservedSectors;}

/** Returns the number of Fats on the volume */

TInt TFatBootSector::NumberOfFats() const

{return iNumberOfFats;}

/** Returns the number of entries allowed in the root directory, specific to Fat12/16, zero for FAT32 */

TInt TFatBootSector::RootDirEntries() const

{return iRootDirEntries;}

/** Returns the total sectors on the volume, zero for FAT32 */

TInt TFatBootSector::TotalSectors() const

{return iTotalSectors;}

/** Returns the media descriptor */

TUint8 TFatBootSector::MediaDescriptor() const

{return iMediaDescriptor;}

/** Returns sectors used for the Fat table, zero for FAT32 */

TInt TFatBootSector::FatSectors() const

{return iFatSectors;}

/** Returns sectors per track */

TInt TFatBootSector::SectorsPerTrack() const

{return iSectorsPerTrack;}

/** Returns the number of heads  */

TInt TFatBootSector::NumberOfHeads() const

{return iNumberOfHeads;}

/** Returns the number of hidden sectors in the volume */

TInt TFatBootSector::HiddenSectors() const

{return iHiddenSectors;}

/** Returns total sectors in the volume, Used if totalSectors > 65535 */

TInt TFatBootSector::HugeSectors() const

{return iHugeSectors;}

/** Returns the physical drive number, not used in Symbian OS */

TInt TFatBootSector::PhysicalDriveNumber() const

{return iPhysicalDriveNumber;}

/** Returns the extended boot signiture */

TInt TFatBootSector::ExtendedBootSignature() const

{return iExtendedBootSignature;}

/** Returns the unique volume ID */

TUint32 TFatBootSector::UniqueID() const

{return iUniqueID;}

/** Returns the volume's label */

const TPtrC8 TFatBootSector::VolumeLabel() const

{return TPtrC8(iVolumeLabel,KVolumeLabelSize);}

/** Returns the file system type */

const TPtrC8 TFatBootSector::FileSysType() const

{return TPtrC8(iFileSysType,KFileSysTypeSize);}

/** Returns the boot sector signiture */

TInt TFatBootSector::BootSectorSignature() const

{return KBootSectorSignature;}

/** Set the jump instruction  */

void TFatBootSector::SetJumpInstruction()

{iJumpInstruction[0]=0xE9;iJumpInstruction[2]=0x90;}

/** Set the vendor ID of the file system that formatted the volume */

void TFatBootSector::SetVendorID(const TDesC8& aDes)

{

	ASSERT(aDes.Length()<=KVendorIdSize);

	TPtr8 buf(iVendorId,KVendorIdSize);

	buf=aDes;

}

/** Sets the bytes per sector  */

void TFatBootSector::SetBytesPerSector(TInt aBytesPerSector)

{

	ASSERT(!(aBytesPerSector&~KMaxTUint16));

	iBytesPerSector=(TUint16)aBytesPerSector;

}

/** Set the sectors per cluster ratio */

void TFatBootSector::SetSectorsPerCluster(TInt aSectorsPerCluster)

{

	ASSERT(!(aSectorsPerCluster&~KMaxTUint8));

	iSectorsPerCluster=(TUint8)aSectorsPerCluster;

}

/** Sets the number of reserved sectors on the volume */

void TFatBootSector::SetReservedSectors(TInt aReservedSectors)

{

	ASSERT(!(aReservedSectors&~KMaxTUint16));

	iReservedSectors=(TUint16)aReservedSectors;

}

/** Sets the number of Fats on the volume */

void TFatBootSector::SetNumberOfFats(TInt aNumberOfFats)

{

	ASSERT(!(aNumberOfFats&~KMaxTUint8));

	iNumberOfFats=(TUint8)aNumberOfFats;

}

/** Number of entries allowed in the root directory, specific to Fat12/16, zero for FAT32 */

void TFatBootSector::SetRootDirEntries(TInt aRootDirEntries)

{

	ASSERT(!(aRootDirEntries&~KMaxTUint16));

	iRootDirEntries=(TUint16)aRootDirEntries;

}

/** Total sectors on the volume, zero for FAT32 */

void TFatBootSector::SetTotalSectors(TInt aTotalSectors)

{

	ASSERT(!(aTotalSectors&~KMaxTUint16));

	iTotalSectors=(TUint16)aTotalSectors;

}

/** Set the media descriptor */

void TFatBootSector::SetMediaDescriptor(TUint8 aMediaDescriptor)

{iMediaDescriptor=aMediaDescriptor;}

/** Sectors used for the Fat table, zero for FAT32 */

void TFatBootSector::SetFatSectors(TInt aFatSectors)

{

	ASSERT(!(aFatSectors&~KMaxTUint16));

	iFatSectors=(TUint16)aFatSectors;

}

/** Set the sectors per track */

void TFatBootSector::SetSectorsPerTrack(TInt aSectorsPerTrack)

{

	ASSERT(!(aSectorsPerTrack&~KMaxTUint16));

	iSectorsPerTrack=(TUint16)aSectorsPerTrack;

}

/** Set the number of heads */

void TFatBootSector::SetNumberOfHeads(TInt aNumberOfHeads)

{

	ASSERT(!(aNumberOfHeads&~KMaxTUint16));

	iNumberOfHeads=(TUint16)aNumberOfHeads;

}

/** Set the number of hidden sectors in the volume */

void TFatBootSector::SetHiddenSectors(TUint32 aHiddenSectors)

{

	iHiddenSectors=(TUint32)(aHiddenSectors);

}

/** Set the total sectors in the volume, Used if totalSectors > 65535 */

void TFatBootSector::SetHugeSectors(TUint32 aHugeSectors)

{iHugeSectors=aHugeSectors;}

/** Physical drive number, not used in Symbian OS */

void TFatBootSector::SetPhysicalDriveNumber(TInt aPhysicalDriveNumber)

{

	ASSERT(!(aPhysicalDriveNumber&~KMaxTUint8));

	iPhysicalDriveNumber=(TUint8)aPhysicalDriveNumber;

}

/** Set the reserved byte value */

void TFatBootSector::SetReservedByte(TUint8 aReservedByte)

{iReserved=aReservedByte;}

/** Set the extended boot signiture */

void TFatBootSector::SetExtendedBootSignature(TInt anExtendedBootSignature)

{

	ASSERT(!(anExtendedBootSignature&~KMaxTUint8));

	iExtendedBootSignature=(TUint8)anExtendedBootSignature;

}

/** Set the unique volume ID */

void TFatBootSector::SetUniqueID(TUint32 anUniqueID)

{iUniqueID=anUniqueID;}

/** Set the volume's label */

void TFatBootSector::SetVolumeLabel(const TDesC8& aDes)

{

	ASSERT(aDes.Length()<=KVolumeLabelSize);

	TPtr8 buf(iVolumeLabel,KVolumeLabelSize);

	buf=aDes;

}

/** Set the file system type */

void TFatBootSector::SetFileSysType(const TDesC8& aDes)

{

	ASSERT(aDes.Length()<=8);

	TPtr8 buf(iFileSysType,8);

	buf=aDes;

}

/** @return The first Fat sector number */

TInt TFatBootSector::FirstFatSector() const

{

    __ASSERT_ALWAYS(IsValid(), User::Invariant());

    return ReservedSectors();

}

/**

    @return Number of sectors in root directory. 0 for FAT32

*/

TUint32 TFatBootSector::RootDirSectors() const

{

    __ASSERT_ALWAYS(IsValid(), User::Invariant());

    return ( (RootDirEntries()*KSizeOfFatDirEntry + (BytesPerSector()-1)) / BytesPerSector() );

}

/** @return Start sector number of the root directory */

TInt TFatBootSector::RootDirStartSector()  const

{

    __ASSERT_ALWAYS(IsValid(), User::Invariant());

    const TUint32 firstNonFatSec = ReservedSectors() + TotalFatSectors()*NumberOfFats();

    if(FatType() == EFat32)

    {//-- FAT32 root dir is a file, calculate the position by it's 1st cluster number. FAT[0]+FAT[1] are reserved.

        return (firstNonFatSec + (RootClusterNum()-KFatFirstSearchCluser) * SectorsPerCluster());

    }

    else

    {//-- FAT12/16 root dir starts just after the FATs

        return firstNonFatSec;

    }

}

/** @return first data sector number. for FAT32 it includes the root directory */

TInt TFatBootSector::FirstDataSector() const

{

    return( ReservedSectors() + NumberOfFats()*TotalFatSectors() + RootDirSectors() );

}

/** @return FAT-type independent sector count on the volume */

TUint32 TFatBootSector::VolumeTotalSectorNumber() const

{

    __ASSERT_ALWAYS(IsValid(), User::Invariant());

    return HugeSectors() ? (TUint32)HugeSectors() : (TUint32)TotalSectors();

}

/** @return FAT-type independent number of sectors in one FAT */

TUint32 TFatBootSector::TotalFatSectors() const

{

    __ASSERT_ALWAYS(IsValid(), User::Invariant());

    return FatSectors32() ? FatSectors32() : (TUint32)FatSectors();

}

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

const TUint32   KLeadSignature      = 0x41615252; ///< FSInfo Lead signiture value

const TUint32   KStructureSignature = 0x61417272; ///< FSInfo Structure signiture value

const TUint32   KTrailingSignature  = 0xAA550000; ///< FSInfo Trailing signiture

TFSInfo::TFSInfo()

{

    Initialise();

}

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

/** Initialise the data */

void TFSInfo::Initialise()  

{

    Mem::FillZ(this, sizeof(TFSInfo));

    iLeadSig      = KLeadSignature; 

    iStructureSig = KStructureSignature;

    iTrainlingSig = KTrailingSignature;

}

TBool TFSInfo::operator==(const TFSInfo& aRhs)

{

    ASSERT(&aRhs != this);

    if(&aRhs == this)

        return ETrue; //-- comparing with itself

    return  (Mem::Compare((TUint8*)this, sizeof(TFSInfo), (TUint8*)&aRhs, sizeof(TFSInfo)) == 0);

}

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

/**

    @return ETrue if FSInfo sector contents seems to be valid

*/

TBool TFSInfo::IsValid() const

{

    return (iLeadSig == KLeadSignature && iStructureSig == KStructureSignature && iTrainlingSig == KTrailingSignature);

}

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

/**

    Initialize FSInfo sector object from the given bufer. Does not validate the data.

    @param  aBuf buffer with data.

*/

void TFSInfo::Internalize(const TDesC8& aBuf)

{

    ASSERT((TUint32)aBuf.Size() >= KSizeOfFSInfo);

    TInt pos=0;

    Mem::Copy(&iLeadSig, &aBuf[pos],4);      pos+=(KFSInfoReserved1Size+4);

    Mem::Copy(&iStructureSig, &aBuf[pos],4); pos+=4;

    Mem::Copy(&iFreeCount,&aBuf[pos],4);     pos+=4;

    Mem::Copy(&iNextFree,&aBuf[pos],4);      pos+=(4+KFSInfoReserved2Size);

    Mem::Copy(&iTrainlingSig,&aBuf[pos],4);

}

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

/**

    Externalize FSInfo sector object to the given data buffer.

    @param  aBuf buffer to externalize.

*/

void TFSInfo::Externalize(TDes8& aBuf) const

{

    ASSERT((TUint32)aBuf.MaxSize() >= KSizeOfFSInfo);

    aBuf.SetLength(KSizeOfFSInfo);

    aBuf.FillZ();

    TInt pos=0;

    Mem::Copy(&aBuf[pos],&KLeadSignature,4);        pos+=4; 

                                                    pos+=KFSInfoReserved1Size;

    Mem::Copy(&aBuf[pos],&KStructureSignature,4);   pos+=4;

    Mem::Copy(&aBuf[pos],&iFreeCount,4);            pos+=4;

    Mem::Copy(&aBuf[pos],&iNextFree,4);             pos+=4;

                                                    pos+=KFSInfoReserved2Size;

    Mem::Copy(&aBuf[pos],&KTrailingSignature,4);

}

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

/** 

    Print out the FSInfo sector info.

*/

void TFSInfo::PrintDebugInfo() const

{

    DoPrintf(_L("==== FSInfoSector : ====\n"));

    DoPrintf(_L("FSI_LeadSig:   0x%x\n"),iLeadSig);

    DoPrintf(_L("FSI_StrucSig:  0x%x\n"),iStructureSig);

    DoPrintf(_L("FSI_FreeCount: 0x%x\n"),iFreeCount);

    DoPrintf(_L("FSI_NxtFree:   0x%x\n"),iNextFree);

    DoPrintf(_L("FSI_TrailSig:  0x%x\n"),iTrainlingSig);

    DoPrintf(_L("========================\n"));

}

TUint32 TFSInfo::FreeClusterCount() const 

{

    return iFreeCount;

}

TUint32 TFSInfo::NextFreeCluster() const

{

    return iNextFree;

}

void TFSInfo::SetFreeClusterCount(TUint32 aFreeCount)

{

    iFreeCount = aFreeCount;

}

void TFSInfo::SetNextFreeCluster(TUint32 aNextCluster)

{

    iNextFree = aNextCluster;

}

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

/**

    Deciphers the dos time/date entry information and converts to TTime

*/

TTime Fat_Test_Utils::DosTimeToTTime(TInt aDosTime,TInt aDosDate)

	{

	TInt secMask=0x1F;

	TInt minMask=0x07E0;

	TInt hrMask=0xF800;

	TInt dayMask=0x1F;

	TInt monthMask=0x01E0;

	TInt yearMask=0xFE00;