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