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

     }

 }