// 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\ext\fat_ext.cpp

// 

//

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

//! @SYMTestType CT

//! @SYMREQ CR JHAS-68YPX7

//! @SYMTestCaseDesc Test facility used by and bad disk handling test

//! @SYMTestStatus Implemented

//! @SYMTestActions Provided plug-in test extension for FAT

//! @SYMTestExpectedResults N/A

//! @SYMTestPriority Low

//! @SYMAuthor Ying Shi

//! @SYMCreationDate 20/05/2005

//! @See EFat and EFat32 components

//! @file f32test\ext\fat_ext.cpp

#include <e32math.h>

#include "t_fatext.h"

//--------------------------  CFatTestProxyDrive  --------------------------

CFatTestProxyDrive* CFatTestProxyDrive::NewL(CProxyDrive* aProxyDrive, CMountCB* aMount)

    {

    __PRINT(_L("CFatTestProxyDrive::NewL"));

    CFatTestProxyDrive* drive = new(ELeave) CFatTestProxyDrive(aProxyDrive,aMount);

    return(drive);

    }

CFatTestProxyDrive::CFatTestProxyDrive(CProxyDrive* aProxyDrive, CMountCB* aMount)

    : CTestProxyDrive(aProxyDrive,aMount)

    {

    __PRINT(_L("CFatTestProxyDrive::CFatTestProxyDrive"));

    InitL();

    }

TInt CFatTestProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aMessageHandle,TInt aOffset,TInt aFlags)

    {

//    __PRINT(_L("CFatTestProxyDrive::Read"));

    if (CheckEvent(aPos,aLength))

        return KErrCorrupt;

    return CTestProxyDrive::Read(aPos,aLength,aTrg,aMessageHandle,aOffset,aFlags);

    }

TInt CFatTestProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aMessageHandle,TInt aOffset)

    {

    return Read(aPos,aLength,aTrg,aMessageHandle,aOffset,0);

    }

TInt CFatTestProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)

    {

    return Read(aPos,aLength,&aTrg,KLocalMessageHandle,0,0);

    }

TInt CFatTestProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aMessageHandle,TInt anOffset,TInt aFlags)

    {

//    __PRINT(_L("CFatTestProxyDrive::Write"));

    if (CheckEvent(aPos,aLength))

        return KErrCorrupt;

    return CTestProxyDrive::Write(aPos,aLength,aSrc,aMessageHandle,anOffset,aFlags);

    }

TInt CFatTestProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aMessageHandle,TInt anOffset)

    {

    return Write(aPos,aLength,aSrc,aMessageHandle,anOffset,0);

    }

TInt CFatTestProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)

    {

    return Write(aPos,aSrc.Length(),&aSrc,KLocalMessageHandle,0,0);

    }

TInt CFatTestProxyDrive::Format(TFormatInfo& anInfo)

    {

    //__PRINT(_L("CFatTestProxyDrive::Format"));

    TInt len;

    TInt64 pos = ((TInt64)anInfo.i512ByteSectorsFormatted) << KDefaultSectorLog2;

    // base function call in order to get anInfo.iMaxBytesPerFormat

    // for the first time

    if (anInfo.iMaxBytesPerFormat == 0)

        {

        TInt r = CTestProxyDrive::Format(anInfo);

        len = anInfo.iMaxBytesPerFormat;

        if (CheckEvent(pos,len))

            {

            anInfo.i512ByteSectorsFormatted = 0;

            return KErrCorrupt;

            }

        return r;

        }

    len = anInfo.iMaxBytesPerFormat;

    if (CheckEvent(pos,len))

        return KErrCorrupt;

    return CTestProxyDrive::Format(anInfo);

    }

TInt CFatTestProxyDrive::Format(TInt64 aPos,TInt aLength)

    {

    __PRINT(_L("CFatTestProxyDrive::Format"));

    if (CheckEvent(aPos,aLength))

        return KErrCorrupt;

    return CTestProxyDrive::Format(aPos, aLength);

    }

void CFatTestProxyDrive::DoInitL()

    {

    __PRINT(_L("CFatTestProxyDrive::DoInit"));

    if (!CheckMount())

        User::Leave(KErrNotReady);

    iTotalSectors = iBootSector.VolumeTotalSectorNumber();

    }

TInt CFatTestProxyDrive::DoControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2)

    {

    __PRINT(_L("CFatTestProxyDrive::DoControlIO"));

	// read boot sector & update iFatType etc

	CheckMount();

    TInt r = KErrNone;

	// Make sure that the information is up to date.

    if ((r=ReadBootSector()) != KErrNone)

        {

        __PRINT1(_L("ReadBootSector error: %d"), r);

        return EFalse;

        }

    switch(aCommand+EExtCustom)

        {

        case ESectorsPerCluster:

            r = aMessage.Write(2, TPckgBuf<TInt>(iBootSector.SectorsPerCluster()));

            break;

        case EFatType:

            r = aMessage.Write(2, TPckgBuf<TInt>(iBootSector.FatType()));

            break;

        case EGetDataPosition:

            {

                //-- obtain 1st data sector media position. This is actually a nasty hack;

                //-- we expect that the drive will be freshly formatted, thust the root dir is empty and the first file we create there

                //-- will occupy the certain place.

                TUint32 dataSec; 

                if(iBootSector.FatType() !=EFat32)

                   dataSec = iBootSector.FirstDataSector();

                else

                  {//-- for FAT32 we assume that the root dir takes exactly 1 cluster. Another dirty trick

                   dataSec = iBootSector.RootDirStartSector() + 1*iBootSector.SectorsPerCluster(); 

                  }

                __PRINT1(_L("EGetDataPosition, sec:%d"), dataSec);

                r = aMessage.Write(2, TPckgBuf<TInt>(dataSec << KDefaultSectorLog2));

            }

            break;

        default:

            r = CBaseExtProxyDrive::ControlIO(aMessage,aCommand,aParam1,aParam2);

            __PRINT2(_L("Get unknown command %d error %d"), aCommand, r);

        }

    return r;

    }

TBool CFatTestProxyDrive::DoCheckEvent(TInt64 aPos, TInt aLength)

    {

    //__PRINT2(_L("CFatTestProxyDrive::DoCheckEvent() pos:%d, len:%d"), (TUint32)aPos, aLength);

    if (aPos<0 || aLength<=0 || (aPos>>KDefaultSectorLog2)>=iTotalSectors)

        return EFalse;

    TInt begin = (TInt)(aPos >> KDefaultSectorLog2);

    TInt end = (TInt)((aPos+aLength-1) >> KDefaultSectorLog2);

    end = Min(end, iTotalSectors-1);

    if (iEventType == ENext)

        {

        Mark(begin);

        iEventType = ENone;

        iLastErrorReason = TErrorInfo::EBadSector;

        iSuccessBytes = 0;

        return ETrue;

        }

    if (iEventType == EDeterministic)

        {

        if (iCount <= end-begin+1)

            {

            iCount = 0;

            Mark(begin+iCount-1);

            iEventType = ENone;

            iLastErrorReason = TErrorInfo::EBadSector;

            iSuccessBytes = (iCount-1) << KDefaultSectorLog2;

            return ETrue;

            }

        else

            iCount -= end-begin+1;

        }

    TInt i;

    for (i=begin; i<=end; i++)

        if (IsMarked(i))

            {

            __PRINT(_L("CFatTestProxyDrive::DoCheckEvent() Sector Marked as bad!"));

            iLastErrorReason = TErrorInfo::EBadSector;

            iSuccessBytes = (i-begin) << KDefaultSectorLog2;

            return ETrue;

            }

    return EFalse;

    }

TBool CFatTestProxyDrive::CheckMount()

    {

    __PRINT(_L("CFatTestProxyDrive::CheckMount"));

    //-- read boot sector

    if (ReadBootSector() != KErrNone)

        {

        __PRINT(_L("ReadBootSector error: %d"));

        return EFalse;

        }

    //-- validate boot sector

    if(!iBootSector.IsValid())

    {

        goto BadBootSector;

    }

    if (iBootSector.FatType() == EFat32)   // fat 32

        {

        if (iBootSector.RootDirEntries() != 0   ||

            iBootSector.TotalSectors() != 0     ||

            iBootSector.HugeSectors() == 0      ||

            iBootSector.FatSectors32() == 0     ||

            iBootSector.RootClusterNum() < 2)

            {

                goto BadBootSector;

            }

        }

    else // fat16/12

        {

        if (iBootSector.RootDirEntries() == 0 ||

            (iBootSector.TotalSectors() == 0 && iBootSector.HugeSectors() == 0))

            {

                goto BadBootSector;

            }

        }

    //-- boot sector is OK

    return ETrue;

    //-- Invalid boot sector

    BadBootSector:

        __PRINT(_L("Boot sector is invalid! dump:"));

        iBootSector.PrintDebugInfo();

        return EFalse;

    }

TInt CFatTestProxyDrive::ReadBootSector()

    {

    __PRINT(_L("CFatTestProxyDrive::ReadBootSector"));

    const TInt KBufSz = KSizeOfFatBootSector;

    TBuf8<KBufSz> bootSecBuf(KBufSz);

    TInt r = CTestProxyDrive::Read(0, KBufSz, bootSecBuf);

	if (r != KErrNone)

		return r;

    //-- initialise TFatBootSector object

    iBootSector.Internalize(bootSecBuf);

    return KErrNone;

    }

// --------------------------  CFatTestProxyDriveFactory  --------------------------

/**

Factory class constructor

@internalTechnology

*/

CFatTestProxyDriveFactory::CFatTestProxyDriveFactory()

    {

    }

/**

Factory class installer

@internalTechnology

*/

TInt CFatTestProxyDriveFactory::Install()

    {

    __PRINT(_L("CFatTestProxyDriveFactory::Install"));

    _LIT(KFatTestExt,"FatTest");

    return(SetName(&KFatTestExt));

    }

/**

@internalTechnology

*/

CProxyDrive* CFatTestProxyDriveFactory::NewProxyDriveL(CProxyDrive* aProxy,CMountCB* aMount)

    {

    __PRINT(_L("CFatTestProxyDriveFactory::NewProxyDriveL"));

    return(CFatTestProxyDrive::NewL(aProxy,aMount));

    }

/**

@internalTechnology

*/

extern "C" {

EXPORT_C CProxyDriveFactory* CreateFileSystem()

    {

    __PRINT(_L("CreateFileSystem"));

    return new CFatTestProxyDriveFactory();

    }

}