// 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 utilities 

// 

//

#include "f32_test_utils.h"

using namespace F32_Test_Utils;

#include "filesystem_fat.h"

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

//-- 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>

//-- Note that the writable static data are not allowed in DLLs i.e. plugins or somethig else.

//-- Thus it needs to be thrown away by preprocessing in such a case.

static CConsoleBase* pConsole = NULL;   //-- pointer to the text console for printing out data

static TBool  bPrintOutEnabled = ETrue; //-- global flag, if EFalse, all printing out is disabled

/**

    Set the console where the ouput will go.

    @param  apConsole pointer to the console. if NULL, the print out will be debug port only.

*/

void F32_Test_Utils::SetConsole(CConsoleBase* apConsole)

{

    pConsole = apConsole;

}

/** 

    Enable or disable printing out. See DoPrintf()

    @param  bEnable If ETrue, print out is enabled

    @return previous value of the global bPrintOutEnabled flag

*/

TBool F32_Test_Utils::EnablePrintOutput(TBool bEnable)

{

    TBool bPrevVal = bPrintOutEnabled;

    bPrintOutEnabled = bEnable;

    return bPrevVal;

}

/**

    Print out the drive information.

    @param  aFs             reference to the FS session

    @param  aDrive          drive number

    @return system-wide error codes.

*/

TInt F32_Test_Utils::PrintDrvInfo(RFs &aFs, TInt aDrive)

{

    TInt        nRes;

    TDriveInfo  driveInfo;

    TVolumeInfo volInfo;

    TBuf<256>   Buf;

    //-- get drive info

    nRes = aFs.Drive(driveInfo, aDrive);

    if(nRes != KErrNone)

        return nRes;

    nRes = aFs.Volume(volInfo, aDrive);

    if(nRes != KErrNone)

        return nRes;

    DoPrintf(_L("Drive %c: #%d\n"), 'A'+aDrive, aDrive);

    //-- print the FS name

    nRes = aFs.FileSystemName(Buf, aDrive);

    if(nRes != KErrNone)

        return nRes;

    //-- to find out FS sub type

    TFSName fsName;

    nRes = aFs.FileSystemSubType(aDrive, fsName); 

    if(nRes == KErrNone && Buf.CompareF(fsName) !=KErrNone)

    {

        Buf.AppendFormat(_L(" (%S)"), &fsName);

    }

   DoPrintf(_L("FS name: %S\n"), &Buf);

   //-- print drive and media attributes

   DoPrintf(_L("MediaType: 0x%x\n"), driveInfo.iType);

   DoPrintf(_L("DriveAtt:0x%x\n"),driveInfo.iDriveAtt);

   DoPrintf(_L("MediaAtt:0x%x\n"),driveInfo.iMediaAtt);

   //-- volume information

   DoPrintf(_L("VolId:0x%x\n"),volInfo.iUniqueID);

   DoPrintf(_L("VolSz:%ld (%ldK)\n"),volInfo.iSize, volInfo.iSize/1024);

   DoPrintf(_L("Free:%ld (%ldK)\n"),volInfo.iFree, volInfo.iFree/1024);

   return KErrNone;

}

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

/**

    Fill a media region with a given byte pattern

    @param  aFs             reference to the FS session

    @param  aDrive          drive number

    @param  aMediaStartPos  media region start position  

    @param  aMediaEndPos    media region end position

    @param  aBytePattern    byte to fill the media region with

    @return system-wide error codes.

*/

TInt F32_Test_Utils::FillMedia(RFs &aFs, TInt aDrive, TInt64 aMediaStartPos, TInt64 aMediaEndPos, TUint8 aBytePattern/*=0*/)

{

    DoPrintf(_L("~ F32_Test_Utils::FillMedia() drv:%d, from:%u to:%u\n"),aDrive, (TUint32)aMediaStartPos, (TUint32)aMediaEndPos);

    ASSERT(aMediaStartPos<=aMediaEndPos && aMediaStartPos >=0  && aMediaEndPos >=0);

    TInt  nRes = KErrNone;

    RBuf8 buf;

    const TUint32 KBufSz=65536; //-- zero-buffer size, bytes

    //-- create a buffer, filled with given pattern

    nRes = buf.CreateMax(KBufSz);

    ASSERT(nRes == KErrNone);

    buf.Fill(aBytePattern);

    TUint32 rem = (TUint32)(aMediaEndPos - aMediaStartPos);

    while(rem)

    {

        const TUint32 bytesToWrite=Min(rem, KBufSz);

        TPtrC8 ptrData(buf.Ptr(), bytesToWrite);

        nRes = MediaRawWrite(aFs, aDrive, aMediaStartPos, ptrData); 

        if(nRes != KErrNone && nRes != KErrDiskFull)

            break;

        aMediaStartPos+=bytesToWrite;

        rem-=bytesToWrite;

    }

    buf.Close();

    return nRes;    

}

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

/**

    Raw read from the media.

    @param  aFs         reference to the FS session

    @param  aDrive      drive number

    @param  aMediaPos   media position 

    @param  aLen        how many bytes to read

    @param  aData       descriptor for the data

    @return system-wide error code.

*/

TInt F32_Test_Utils::MediaRawRead(RFs &aFs, TInt aDrive, TInt64 aMediaPos, TUint32 aLen, TDes8& aData)

{

    TInt nRes=KErrNone;

    TRAP(nRes, DoMediaRawReadL(aFs, aDrive, aMediaPos, aLen, aData));

    return nRes;

}

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

/**

    Raw write to the media.

    @param  aFs         reference to the FS session

    @param  aDrive      drive number

    @param  aMediaPos   media position 

    @param  aData       descriptor with the data to write

    @return system-wide error code.

*/

TInt F32_Test_Utils::MediaRawWrite(RFs &aFs, TInt aDrive, TInt64 aMediaPos, const TDesC8& aData)

{

    TInt nRes=KErrNone;

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

    return nRes;

}

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

void F32_Test_Utils::DoMediaRawReadL(RFs &aFs, TInt aDrive, TInt64 aMediaPos, TUint32 aLen, TDes8& aData)

{

    ASSERT(aMediaPos>=0);

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

    if((TUint32)aData.MaxSize() < aLen)

        User::Leave(KErrArgument);

    if(aLen == 0)

        return;

    aData.SetLength(aLen);

    RRawDisk  rawDisk;

    CleanupClosePushL(rawDisk);

    User::LeaveIfError(rawDisk.Open(aFs, aDrive));

    User::LeaveIfError(rawDisk.Read(aMediaPos, aData));

    CleanupStack::PopAndDestroy(&rawDisk);

}

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

void F32_Test_Utils::DoMediaRawWriteL(RFs &aFs, TInt aDrive, TInt64 aMediaPos, const TDesC8& aData)

{

    ASSERT(aMediaPos>=0);

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

    if(aData.Size() == 0)

        return;

    RRawDisk  rawDisk;

    CleanupClosePushL(rawDisk);

    User::LeaveIfError(rawDisk.Open(aFs, aDrive));

    User::LeaveIfError(rawDisk.Write(aMediaPos, (TDesC8&)aData));

    CleanupStack::PopAndDestroy(&rawDisk);

}

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

_LIT(KFsName_LFFS,  "lffs");

_LIT(KFsName_Win32, "Win32");

_LIT(KFsName_ExFAT, "ExFat");

_LIT(KFsName_AutoMonuter, "automounter");

_LIT(KFsName_HVFS, "HVFS");

/**  @return ETrue if "Automounter" FS is mounted on this drive */

TBool F32_Test_Utils::Is_Automounter(RFs &aFs, TInt aDrive)

{

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

    TFSName f;

	TInt r = aFs.FileSystemName(f, aDrive);

    __ASSERT_ALWAYS((r==KErrNone) && (f.Length()>0), User::Invariant());

    return (f.CompareF(KFsName_AutoMonuter) == 0 );

}

/** @return ETrue if "lffs" FS is mounted on this drive */

TBool F32_Test_Utils::Is_Lffs(RFs &aFs, TInt aDrive)

{

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

    TFSName f;

	TInt r = aFs.FileSystemName(f, aDrive);

    __ASSERT_ALWAYS((r==KErrNone) && (f.Length()>0), User::Invariant());

    return (f.CompareF(KFsName_LFFS) == 0 );

}

/** @return ETrue if "Win32" FS is mounted on this drive (i.e this is emulator's drive C:) */

TBool F32_Test_Utils::Is_Win32(RFs &aFs, TInt aDrive)   

{

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

    TFSName f;

	TInt r = aFs.FileSystemName(f, aDrive);

    __ASSERT_ALWAYS((r==KErrNone) && (f.Length()>0), User::Invariant());

    return (f.CompareF(KFsName_Win32) == 0 );

}

/** @return ETrue if "HVFS" is mounted on this drive (i.e PlatSim's drive C:) */

TBool F32_Test_Utils::Is_HVFS(RFs &aFs, TInt aDrive)

{

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

    TFSName f;

	TInt r = aFs.FileSystemName(f, aDrive);

    __ASSERT_ALWAYS((r==KErrNone) && (f.Length()>0), User::Invariant());

    return (f.CompareF(KFsName_HVFS) == 0);

}

/** @return ETrue if "HVFS" or "Win32" FS is mounted on this drive

 * 			(i.e drive C: of PlatSim or the emulator) */

TBool F32_Test_Utils::Is_SimulatedSystemDrive(RFs &aFs, TInt aDrive)

{

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

    TFSName f;

	TInt r = aFs.FileSystemName(f, aDrive);

    __ASSERT_ALWAYS((r==KErrNone) && (f.Length()>0), User::Invariant());

    return (f.CompareF(KFsName_HVFS) == 0 || f.CompareF(KFsName_Win32) == 0);

}

/** @return ETrue if the filesystem if FAT (fat12/16/32) */

TBool F32_Test_Utils::Is_Fat(RFs &aFs, TInt aDrive)

{

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

    TFSName fsName;

	TInt nRes = aFs.FileSystemName(fsName, aDrive);

    __ASSERT_ALWAYS((nRes==KErrNone) && (fsName.Length()>0), User::Invariant());

    if(fsName.CompareF(KFileSystemName_FAT) == 0)

        return ETrue; //-- "FAT" FS is explicitly mounted on this drive

    //-- try analyse file system subtype for the case of automounter FS

    nRes = aFs.FileSystemSubType(aDrive,fsName); 

    if(nRes !=KErrNone)

        return EFalse;

    return (fsName.CompareF(KFSSubType_FAT16) == 0 || fsName.CompareF(KFSSubType_FAT32) == 0 || fsName.CompareF(KFSSubType_FAT12) == 0);

}

/** returns ETrue if "exFAT" FS is mounted on this drive */

TBool F32_Test_Utils::Is_ExFat(RFs &aFs, TInt aDrive)

{

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

    TFSName fsName;

	TInt nRes = aFs.FileSystemName(fsName, aDrive);

    __ASSERT_ALWAYS((nRes==KErrNone) && (fsName.Length()>0), User::Invariant());

    if(fsName.CompareF(KFsName_ExFAT) == 0 )

        return ETrue; //-- "exFAT" FS is explicitly mounted on this drive

    //-- try analyse file system subtype for the case of automounter FS

    nRes = aFs.FileSystemSubType(aDrive,fsName); 

    if(nRes !=KErrNone)

        return EFalse;

    return (fsName.CompareF(KFsName_ExFAT) == 0);

}

/** @return ETrue if the filesystem if FAT32 */

TBool F32_Test_Utils::Is_Fat32(RFs &aFs, TInt aDrive)

{

    if(!Is_Fat(aFs, aDrive))

        return EFalse;

    TFSName fsName;

    TInt nRes = aFs.FileSystemSubType(aDrive,fsName); 

    if(nRes !=KErrNone)

        return EFalse;

    return (fsName.CompareF(KFSSubType_FAT32) == 0);

}

/** @return ETrue if the filesystem if FAT16 */

TBool F32_Test_Utils::Is_Fat16(RFs &aFs, TInt aDrive)

{

    if(!Is_Fat(aFs, aDrive))

        return EFalse;

    TFSName fsName;

    TInt nRes = aFs.FileSystemSubType(aDrive,fsName); 

    if(nRes !=KErrNone)

        return EFalse;

    return (fsName.CompareF(KFSSubType_FAT16) == 0);

}

/** @return ETrue if the filesystem if FAT12 */

TBool F32_Test_Utils::Is_Fat12(RFs &aFs, TInt aDrive)

{

    if(!Is_Fat(aFs, aDrive))

        return EFalse;

    TFSName fsName;

    TInt nRes = aFs.FileSystemSubType(aDrive,fsName); 

    if(nRes !=KErrNone)

        return EFalse;

    return (fsName.CompareF(KFSSubType_FAT12) == 0);

}

static void DoCreateCheckableFileL(RFile64& aFile, TUint64 aSize)

{

    ASSERT(aSize >= TMD5::HashSize);

    //-- 1. set file size

    User::LeaveIfError(aFile.SetSize((TInt)aSize));

    //-- 2. leave place for the 16-bytes MD5 hash in the file beginning

    TInt64 filePos = TMD5::HashSize;

    User::LeaveIfError(aFile.Seek(ESeekStart,filePos));

    aSize-=TMD5::HashSize;

    TMD5 md5Hash;

    //-- 3. fill the file with random bytes

    const TInt KBufSize=65536; //-- buffer size for writing data

    TInt64 rndSeed = aSize % 43283;

    if(!rndSeed)

        rndSeed = 33521; 

    RBuf8 buf;

    buf.CreateMaxL(KBufSize);

    TUint64 prevSz = aSize;

    while(aSize)

    {

        //-- initialize buffer with random rubbish

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

        {

            buf[i] = (TUint8)Math::Rand(rndSeed);

        }

        const TUint32 nBytes = (TUint32)Min((TUint64)KBufSize, aSize);

        TPtrC8 ptrData(buf.Ptr(), nBytes);

        User::LeaveIfError(aFile.Write(ptrData)); //-- write data to the file

        md5Hash.Update(ptrData); //-- update MD5 hash        

        aSize-=nBytes;

        if((prevSz - aSize) >= K1MegaByte)

        {

            prevSz = aSize;

            DoPrintf(_L("."));

        }

    }

    buf.Close();

    DoPrintf(_L("\n"));

    //-- 4. write MD5 hash to the beginning of the file

    filePos = 0;

    User::LeaveIfError(aFile.Seek(ESeekStart,filePos));

    User::LeaveIfError(aFile.Write(md5Hash.Final()));

}

static void DoVerifyCheckableFileL(RFile64& aFile)

{

    TInt64 fileSize;

    User::LeaveIfError(aFile.Size(fileSize));

    if(fileSize < TMD5::HashSize)

       User::Leave(KErrCorrupt); //-- MD5 hash is 16 bytes, it's the minimal file size

    //-- 1. read MD5 header from the file

    TBuf8<TMD5::HashSize> md5Header(TMD5::HashSize);

    User::LeaveIfError(aFile.Read(md5Header));

    fileSize -= TMD5::HashSize;

    //-- 2. read the rest of the data and calculate the checksum

    TMD5 md5Hash;

    RBuf8 buf;

    const TInt KBufSize=65536; //-- buffer size for writing data

    buf.CreateMaxL(KBufSize);

    TUint64 prevSz = fileSize;

    while(fileSize)

    {

        User::LeaveIfError(aFile.Read(buf)); //-- read data from the file

		if (buf.Length() == 0)

			User::Leave(KErrEof);

        md5Hash.Update(buf); //-- update MD5 hash        

        fileSize-=buf.Length();

        if((prevSz - fileSize) >= K1MegaByte)

        {

            prevSz = fileSize;

            DoPrintf(_L("."));

        }

    }

    buf.Close();

    DoPrintf(_L("\n"));

    if(md5Hash.Final() != md5Header)

        User::Leave(KErrCorrupt); //-- the file is corrupt

}

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

/**

    Creates a file filled with random data. The file has a 16-byte MD5 header at the start, so it is possible to

    verify the data validity later. Thus the minimal file size is 16 bytes. The file with the iven name may already

    exist; in this case it will be replaced.

    @param  aFs         reference to the FS session

    @param  aFileName   name of the file to be created / replaced

    @param  aSize       size of the file; 16 bytes min.

    @return Standard error code

*/

TInt  F32_Test_Utils::CreateCheckableStuffedFile(RFs& aFs, const TDesC& aFileName, TUint64 aSize)

{

    DoPrintf(_L("~ F32_Test_Utils::CreateCheckableStuffedFile() file:%S, Size:%LU\n"), &aFileName, aSize);

    if(aSize < TMD5::HashSize)

        return KErrArgument; //-- MD5 hash is 16 bytes, it's the minimal file size

    RFile64 file;

    //-- 1. create a file

    TInt nRes = file.Replace(aFs, aFileName, EFileWrite);

    if(nRes != KErrNone)