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

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

/**

    Prints out a hex dump of a descriptor contents

    @param  aBuf data descriptor to dump

*/

void  F32_Test_Utils::HexDump(const TDesC8& aBuf)

{

    HexDump(aBuf.Ptr(), aBuf.Size());

}

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

/**

    Prints out a hex dump of a buffer

    @param  apBuf   pointer to the data to dump

    @param  aBufLen buffer length

*/

void  F32_Test_Utils::HexDump(const TAny* apBuf, TUint aBufLen)

{

    DoPrintf(_L("~ F32_Test_Utils::HexDump() size:%u\n"), aBufLen);

    ASSERT(apBuf);

    if(!aBufLen)

        return;

    const TUint colDmpWidth = 16;

    const TUint8* pBuf = (const TUint8*)apBuf;

    TBuf<256> buf1;

    TBuf<64>  buf2;

    TUint dumpPos;

    for(dumpPos=0; dumpPos < aBufLen-1; )

    {

        buf1.Format(_L("%06X: "), dumpPos);

        buf2.Zero();

        for(TUint i=0; i<colDmpWidth; ++i)

        {

            buf1.AppendFormat(_L("%02x "), pBuf[dumpPos+i]);

            const TChar ch = pBuf[dumpPos+i];

            if(ch.IsPrint())

                buf2.Append(ch);

            else    

                buf2.Append(_L("."));

            if(++dumpPos >= aBufLen)

            {    

                while(++i < colDmpWidth)

                {

                    buf1.Append(_L("   "));

                    buf2.Append(_L(" "));

                }

                break;

            }

        }

        buf1.Append(buf2);

        DoPrintf(buf1);

    }

    DoPrintf(_L("\n"));

}

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

/**

    Compare 2 buffers and print out the difference if there is any.

    Buffer sizes must be the same and non-0

    @param  aBuf1   buffer 1 descriptor

    @param  aBuf2   buffer 2 descriptor

    @return ETrue if buffers are the same, EFalse otherwise

*/

TBool F32_Test_Utils::CompareBuffers(const TDesC8& aBuf1, const TDesC8& aBuf2)

{

    return CompareBuffers(aBuf1.Ptr(), aBuf1.Size(), aBuf2.Ptr(), aBuf2.Size());

}

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

/**

    Compare 2 buffers and print out the difference if there is any.

    Buffer sizes must be the same and non-0

    @param  apBuf1   pointer to the buffer 1 

    @param  aBuf1Len buffer1 length

    @param  apBuf2   pointer to the buffer 2 

    @param  aBuf2Len buffer2 length

    @return ETrue if buffers are the same, EFalse otherwise

*/

TBool F32_Test_Utils::CompareBuffers(const TAny* apBuf1, TUint aBuf1Len, const TAny* apBuf2, TUint aBuf2Len)

{

    ASSERT(apBuf1 && apBuf2);

    if(aBuf1Len != aBuf2Len)

    {

        DoPrintf(_L("~ F32_Test_Utils::CompareBuffers() different sizes! %u:%u\n"), aBuf1Len, aBuf2Len);

        ASSERT(0);

        return EFalse;

    }

    if(!aBuf1Len)

    {//-- empty buffers to compare

        return ETrue;

    }

    const TUint8* pBuf1 = (const TUint8*)apBuf1;

    const TUint8* pBuf2 = (const TUint8*)apBuf2;   

    if(!Mem::Compare(pBuf1, aBuf1Len, pBuf2, aBuf2Len))

        return ETrue; //-- buffers are the same. 

    //-- the buffers' contents are different

    TUint diffpos;

    TBuf<256> buf1;

    TBuf<100> buf2;

    const TUint colDmpWidth = 16;

    TBool bBannerPrinted = EFalse;

    //-- dump chunks of the buffer with differences only

    for(diffpos=0; diffpos<aBuf1Len-1; )

    {

        if(pBuf1[diffpos] == pBuf2[diffpos])

            {

            ++diffpos;

            continue;

            }

        if(!bBannerPrinted)

        {

            bBannerPrinted = ETrue;

            DoPrintf(_L("~ F32_Test_Utils::CompareBuffers() buffers' contents are different starting at pos:%u (0x%x). Hexdump:\n"), diffpos, diffpos);

        }

        //-- difference found, dump chunks of the buffer with differences only

        TUint dumpPos = (diffpos >> 4) << 4; //-- round down to 16

        buf1.Format(_L("%06X: "), dumpPos);

        buf2.Format(_L("|"));

        for(TUint i=0; i<colDmpWidth; ++i)

        {

            buf1.AppendFormat(_L("%02x"), pBuf1[dumpPos+i]);

            buf2.AppendFormat(_L("%02x"), pBuf2[dumpPos+i]);

            if(i < colDmpWidth-1)

            {

                buf1.Append(_L(" "));

                buf2.Append(_L(" "));

            }

            if(++diffpos >= aBuf1Len)

            {//-- pad the dump with spaces

                while(++i < colDmpWidth)

                {

                    buf1.Append(_L("   "));

                    buf2.Append(_L("   "));

                }

                break;

            }

        }

        buf1.Append(buf2);

        DoPrintf(buf1);

    }

    DoPrintf(_L("\n"));

    return EFalse;

}

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

/**

    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)