// Copyright (c) 1998-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\filesystem\fat\t_tscan32.cpp

// 

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "fat_utils.h"

using namespace Fat_Test_Utils;

/*

Series of tests to check that the combination of a ruggedised fat file

system and scandisk prevents the file system from becoming corrupt in the

event of a power failure. CheckDisk is used to test that directory

structure is not corrupt. This test is only suitable with a drive that uses

the fat file system but not the internal ram drive (due to the indirection)

table. Only works with debug builds due to RFs::ControlIo only debug function

*/

GLDEF_D TFileName StartupExeName=_L(""); // initialised at run time

#ifdef _DEBUG

GLREF_D RTest test;

GLDEF_D TInt TheFunctionNumber;	// Indicates which test to run

GLDEF_D TInt TheOpNumber;		// Indicates which file operation to be tested

GLDEF_D TInt TheFailCount;		

GLDEF_D TBool IsReset;

GLDEF_D TFileName TestExeName=_L("?:\\T_SCANDR.EXE"); //Renaming it to fit in one root dir entry.

GLDEF_D TFileName LogFileName=_L("?:\\T_SCANDR.LOG"); //Renaming it to fit in one root dir entry.

const TInt KControlIoWriteFailOn=0;		// commands to pass into RFs::ControlIo

const TInt KControlIoWriteFailOff=1;

const TInt KMaxFatEntries  = 2048;

const TInt KDirAttrReadOnly  = 0x01;

const TInt KDirAttrHidden    = 0x02;

const TInt KDirAttrSystem    = 0x04;

const TInt KDirAttrVolumeId  = 0x08;

const TInt KDirAttrDirectory = 0x10;

const TInt KDirAttrArchive   = 0x20;

const TInt KDirAttrLongName  = KDirAttrReadOnly | KDirAttrHidden | KDirAttrSystem | KDirAttrVolumeId;

const TInt KDirAttrLongMask  = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;

const TInt KDirLastLongEntry = 0x40;

GLDEF_D TInt WriteFailValue;	// Indicates what error should return from a write failure

								// Value assigned in t_scn32dr2 and t_scn32dr3

LOCAL_C TFatBootSector BootSector;	

LOCAL_D RRawDisk TheRawDisk;

static TFatType gDiskType = EInvalid;

LOCAL_D TInt gTotalSectors;

LOCAL_D TInt gBytesPerCluster;

LOCAL_D TInt gRootDirSectors;

LOCAL_D TInt gRootDirEntries;

LOCAL_D TInt gRootDirStart;

LOCAL_D TInt gRootSector;

LOCAL_D TInt gFatStartBytes;

LOCAL_D TInt gFatTestEntries;

LOCAL_D TInt gFatSizeSectors;

LOCAL_D TInt gFirstDataSector;

LOCAL_D TInt gDataStartBytes;

LOCAL_D TInt gClusterCount;

LOCAL_D HBufC8* gFatBuf  = NULL;

LOCAL_D TInt    gFatAddr = -1;

enum TFatChain

	{

	EChainStd,			// Cluster chain grows contiguously

	EChainAlternate,	// Cluster chain grows forward but not contiguously

	EChainBackwards,	// Cluster chain first goes backwards(up to 3.5kb for fat16 file) and then forwards

	EChainForwards		// Cluster chain first goes forward (upto 3.5kb for fat16 file) and then backwards

	};

LOCAL_C TBool IsInternalRam()

//

// Returns true if the selected drive is variable size (i.e. RAM drive)

//

	{

	TVolumeInfo v;

	TInt r=TheFs.Volume(v,gSessionPath[0]-'A');

	test_KErrNone(r);

	return(v.iDrive.iMediaAtt&KMediaAttVariableSize);

	}

LOCAL_C void WriteLogFile()

//

// Writes state of test to end of LogFileName

//

	{

	test.Printf(_L("Writelogfile()\n"));

	RFile log;

	TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive|EFileWrite);

	if(r!=KErrNone)

		test.Printf(_L("error=%d\n"),r);

	test_KErrNone(r);

	TInt size;

	r=log.Size(size);

	test_KErrNone(r);

	TBuf8<16> buf;

	buf.SetLength(4);

	buf[0]=(TUint8)TheFunctionNumber;

	buf[1]=(TUint8)TheOpNumber;

	buf[2]=(TUint8)TheFailCount;

	buf[3]='\n';

	r=log.Write(size,buf,buf.Length());

	test_KErrNone(r);

	test.Printf(_L("Written func=%d,op=%d,fail=%d\n"),TheFunctionNumber,TheOpNumber,TheFailCount);

	log.Close();

	}

LOCAL_C TInt SetWriteFailOn(TInt aFailCount)

//

// Sets write to metadata to fail on aFailCount with WriteFailValue

//

	{

	TInt16 args[2];

	TPtr8 des((TUint8*)args,4,4);

	args[0]=(TUint16)aFailCount;

	args[1]=(TUint16)WriteFailValue;

	TInt r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOn,des);

	return(r);

	}

GLDEF_C void ReadLogFile()

//

// Reads state of test from end of LogFileName and sets global variables

//

	{

	test.Next(_L("ReadLogFile"));

	RFile log;

	TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive);

	if(r!=KErrNone)

		test.Printf(_L("error in ReadLogFile()=%d\n"),r);

	test_KErrNone(r);

	TInt fileSize;

	r=log.Size(fileSize);

	if(fileSize==0)

		{

		TheFunctionNumber=0;

		TheOpNumber=0;

		TheFailCount=0;

		}

	else

		{

		TBuf8<4> buf;

		r=log.Read(fileSize-4,buf,4);

		TheFunctionNumber=buf[0];

		TheOpNumber=buf[1];

		TheFailCount=buf[2];

		}

	log.Close();

	test.Printf(_L("func=%d,op=%d,fail=%d\n"),TheFunctionNumber,TheOpNumber,TheFailCount);

	}

LOCAL_C TUint32 MaxClusters()

	//

	// Return the number of data clusters on the disk

	//

	{

	TUint32 totSec = (BootSector.TotalSectors() ? BootSector.TotalSectors() : BootSector.HugeSectors());

	TUint32 numSec = totSec - gFirstDataSector;

	return numSec / BootSector.SectorsPerCluster();

	}

LOCAL_C TInt ClusterToByte(TInt aCluster)

	//

	// converts cluster number to byte offset on disk

	//

	{

	TInt sector = (aCluster - 2) * gBytesPerCluster + gFirstDataSector * BootSector.BytesPerSector();

	return sector;

	}

/**

    Fill media with zeroes from aStartPos to aEndPos

*/

static void DoZeroFillMedia(TInt64 aStartPos, TInt64 aEndPos, RRawDisk& aWriter)

{

	test(aStartPos >=0 && aEndPos >=0 && aStartPos < aEndPos);

    if(aStartPos == aEndPos)

        return;

    RBuf8 buf;

    TInt  nRes;  

    const TUint32 KBufSz=65536*2; //-- buffer with zeroes

    nRes = buf.CreateMax(KBufSz);

    test_KErrNone(nRes);

    buf.FillZ();

    TUint32 rem = (TUint32)(aEndPos - aStartPos);

    while(rem)

    {

        const TUint32 bytesToWrite=Min(rem, KBufSz);

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

        nRes = aWriter.Write(aStartPos, ptr);

        test_Value(nRes, nRes == KErrNone || nRes == KErrDiskFull);

        aStartPos+=bytesToWrite;

        rem-=bytesToWrite;

    }

    buf.Close();

}

//

// Clear the disk data area to a known value which won't be confused with

// directory entries etc.

//

LOCAL_C void ClearDiskData()

	{

	TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

	test_KErrNone(r);

	TUint32 startPos = gDataStartBytes;

	if (gDiskType == EFat32)

		startPos += gBytesPerCluster;

    const TUint32 endPos = startPos + gFatTestEntries*gBytesPerCluster;

    test.Printf(_L("ClearDiskData() from pos:%u to pos:%u\n"), startPos, endPos);

    DoZeroFillMedia(startPos, endPos, TheRawDisk);

	TheRawDisk.Close();

	}

LOCAL_C TInt PosInBytes(TInt aFatIndex)

//

// Return number of bytes into the FAT

//

	{

	TInt fatPosInBytes = -1;

	switch (gDiskType)

		{

		case EFat32:

			fatPosInBytes=aFatIndex<<2;

			break;

		case EFat16:

			fatPosInBytes=aFatIndex<<1;

			break;

		case EFat12:

			fatPosInBytes=(aFatIndex*3>>1);

			break;

		default:

			test(0);

		}

	return(fatPosInBytes);

	}

static void DoReadBootSector()

	{

    TInt nRes = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, BootSector);

    test_KErrNone(nRes);

    if(!BootSector.IsValid())

        {

        test.Printf(_L("Wrong bootsector! Dump:\n"));

        BootSector.PrintDebugInfo();

        test(0);

        }

	// Calculate derived variables (fixed for a particular disk format)

	gBytesPerCluster   = BootSector.BytesPerSector() * BootSector.SectorsPerCluster();

	gRootDirSectors    = ((BootSector.RootDirEntries() * KSizeOfFatDirEntry + BootSector.BytesPerSector() - 1) / BootSector.BytesPerSector());

	gFatStartBytes     = BootSector.ReservedSectors() * BootSector.BytesPerSector();

	gFatSizeSectors    = (BootSector.FatSectors() ? BootSector.FatSectors() : BootSector.FatSectors32());

	gRootSector        = BootSector.ReservedSectors() + BootSector.NumberOfFats() * gFatSizeSectors;

	gRootDirStart      = gRootSector * BootSector.BytesPerSector();

	gFirstDataSector   = gRootSector + gRootDirSectors;

	gFatTestEntries = MaxClusters();

	if (gFatTestEntries > KMaxFatEntries)

		gFatTestEntries = KMaxFatEntries;

	if (BootSector.RootDirEntries() == 0)

		{

		test.Printf(_L("**** Is Fat32\n"));

		gDiskType = EFat32;

		gRootDirEntries = BootSector.RootDirEntries();

		}

	else if (BootSector.FatType() == EFat16)

		{

		test.Printf(_L("**** Is Fat16\n"));

		gDiskType = EFat16;

		gRootDirEntries = BootSector.RootDirEntries();

		}

	else

		{

		test.Printf(_L("**** Is Fat12\n"));

		gDiskType = EFat12;

		gRootDirEntries = gBytesPerCluster * 1 / KSizeOfFatDirEntry;

		}

	gTotalSectors   = (BootSector.TotalSectors() ? BootSector.TotalSectors() : BootSector.HugeSectors());

	gClusterCount   = (gTotalSectors - gFirstDataSector) / BootSector.SectorsPerCluster();

	gDataStartBytes = gFirstDataSector * BootSector.BytesPerSector();

	}

GLDEF_C TUint32 GetFatEntry(TUint32 aIndex, const TUint8* aFat=NULL)

//

// Read a single FAT entry from disk or FAT copy and return it

//

	{

	if (!gFatBuf)

		{

		gFatBuf=HBufC8::New(gBytesPerCluster);

		test_NotNull(gFatBuf);

		gFatAddr = -1;

		}

	const TUint8* ptr;

	if (aFat)

		{

		ptr = (TUint8*)aFat + PosInBytes(aIndex);

		}

	else

		{

		TInt pos = PosInBytes(aIndex) + gFatStartBytes;

		if (gFatAddr < 0 || pos < gFatAddr || pos >= gFatAddr + gBytesPerCluster)

			{

			TPtr8 ptr=gFatBuf->Des();

			TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');

			test_KErrNone(r);

			r=TheRawDisk.Read(pos, ptr);

			test_KErrNone(r);

			TheRawDisk.Close();

			gFatAddr = pos;

			}

		ptr = gFatBuf->Ptr() + pos-gFatAddr;

		}

	TUint32 val = 0;

	switch (gDiskType)

		{

		case EFat32:

			val = *(TUint32*)ptr;

			break;

		case EFat16:

			val = *(TUint16*)ptr;

			break;

		case EFat12:

			val = *(TUint16*)ptr;

			if (aIndex & 1)

				val >>= 4;

			val &= 0xFFF;

			break;

		default:

			test(0);

		}

	return val;

	}

GLDEF_C void DumpBootSector()

//

// Display (in log) TFatBootSector structure

//

	{

	RDebug::Print(_L("iBytesPerSector    = %8d"), BootSector.BytesPerSector());

	RDebug::Print(_L("iSectorsPerCluster = %8d"), BootSector.SectorsPerCluster());

	RDebug::Print(_L("iReservedSectors   = %8d"), BootSector.ReservedSectors());

	RDebug::Print(_L("iNumberOfFats      = %8d"), BootSector.NumberOfFats());

	RDebug::Print(_L("iRootDirEntries    = %8d"), BootSector.RootDirEntries());

	RDebug::Print(_L("iTotalSectors      = %8d"), BootSector.TotalSectors());

	RDebug::Print(_L("iMediaDescriptor   = %8d"), BootSector.MediaDescriptor());

	RDebug::Print(_L("iFatSectors        = %8d"), BootSector.FatSectors());

	RDebug::Print(_L("iSectorsPerTrack   = %8d"), BootSector.SectorsPerTrack());

	RDebug::Print(_L("iNumberOfHeads     = %8d"), BootSector.NumberOfHeads());

	RDebug::Print(_L("iHiddenSectors     = %8d"), BootSector.HiddenSectors());

	RDebug::Print(_L("iHugeSectors       = %8d"), BootSector.HugeSectors());

	//New for FAT32

	if(BootSector.RootDirEntries() == 0)	//indicates we have FAT32 volume

		{

		RDebug::Print(_L("FatSectors32      = %8d"), BootSector.FatSectors32());

		RDebug::Print(_L("FATFlags          = %8d"), BootSector.FATFlags());

		RDebug::Print(_L("VersionNumber     = %8d"), BootSector.VersionNumber());

		RDebug::Print(_L("RootClusterNum    = %8d (0x%08X)"), BootSector.RootClusterNum(), gRootDirStart);

		RDebug::Print(_L("FSInfoSectorNum   = %8d (0x%08X)"), BootSector.FSInfoSectorNum(), BootSector.FSInfoSectorNum() * BootSector.BytesPerSector());

		RDebug::Print(_L("BkBootRecSector   = %8d (0x%08X)"), BootSector.BkBootRecSector(), BootSector.BkBootRecSector() * BootSector.BytesPerSector());

		}

	TInt fatEntries = gFatSizeSectors*BootSector.BytesPerSector();

	switch (gDiskType)

		{

		case EFat32:

			fatEntries /= 4;

			break;

		case EFat16:

			fatEntries /= 2;

			break;

		case EFat12:

			fatEntries *= 3;

			fatEntries /= 2;

			break;

		default:

			test(0);

		}

	RDebug::Print(_L("ClusterCount      = %8d (%d bytes)"), gClusterCount, gClusterCount*gBytesPerCluster);

	RDebug::Print(_L("FatEntries        = %8d (%d sectors)"), fatEntries, gFatSizeSectors);

	RDebug::Print(_L("RootSector        = %8d (0x%08X)"), gRootSector, gRootDirStart);

	RDebug::Print(_L("FirstDataSector   = %8d (0x%08X)"), gFirstDataSector, gDataStartBytes);

	}

GLDEF_C void DumpFat(const TUint8* aFat=NULL)

// 

// Dump to the log all those FAT entries which are non-zero

//

	{

	TInt32 max = MaxClusters();

	if (max > KMaxFatEntries)

		max = KMaxFatEntries;

	RDebug::Print(_L("---------------- DUMP OF FAT ---------------"));

	for (TInt32 i = 0; i < max; i++)

		{

		TInt32 val = GetFatEntry(i, aFat);

		TInt32 msk = 0x0FFFFFFF;

		switch (gDiskType)

			{

			case EFat32:

				msk = 0x0FFFFFFF;

				break;

			case EFat16:

				msk = 0xFFFF;

				break;

			case EFat12:

				msk = 0x0FFF;

				break;

			default:

				test(0);

			}

		if ((val & msk) == (0x0FFFFFFF & msk))

			RDebug::Print(_L("    %8d -> EOC"), i);

		else if ((val & msk) == (0x0FFFFFF8 & msk))

			RDebug::Print(_L("    %8d -> Media"), i);

		else if ((val & msk) == (0x0FFFFFF7 & msk))

			RDebug::Print(_L("    %8d -> BAD"), i);

		else if (val > max)

			RDebug::Print(_L("    %8d -> 0x%08X"), i, val);

		else if (val != 0)

			RDebug::Print(_L("    %8d -> %d"), i, val);

		}

	RDebug::Print(_L("--------------------------------------------"));

	}

GLDEF_C TDes* DirAttributes(TInt aAttrib)

// 

// Return a pointer to a local buffer containing the attribute letters.

//

	{

	LOCAL_D TBuf<6> str(_L("------"));

	LOCAL_D char const *   atr = "RHSVDA";

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

		if ((aAttrib >> i) & 1)

			str[i] = atr[i];

	return &str;

	}

GLDEF_C TBool IsValidDirChar(TUint8 aChar, TUint8 aMin=0x20)

//

// Test whether a character is valid as part of a short filename, aMin is to

// distinguish between first character (which can't be space) and later ones

// which can include space but nothing less.  Note that E5 is a valid character

// in any position, even though it means 'erased' in the first character.

//

	{

	const TUint8* inval = (TUint8*)"\x22\x2A\x2B\x2C\x2E\x2F\x3A\x3B\x3C\x3D\x3E\x3F\x5B\x5C\x5D\x7C";

	if (aChar < aMin)

		return EFalse;

	for (const TUint8* p = inval; *p; p++)

		if (aChar == *p)

			return EFalse;

	return ETrue;

	}

GLDEF_C TBool IsValidDirEntry(TFatDirEntry* aDir)

// 

// Test whether buffer is a valid normal directory entry

//

	{

	// top two bits of attributes must be zero

	if (aDir->iData[11] & 0xC0)

		return EFalse;

	// first character must be 0x05 or greater than space

	if (!IsValidDirChar(aDir->iData[0], 0x21) && aDir->iData[0] != 0x05)

		return EFalse;

	// other characters in name must be not less than space

	for (TInt i = 1; i < 11; i++)

		if (!IsValidDirChar(aDir->iData[i]))

			return EFalse;

	return ETrue;

	}

GLDEF_C void GetLongNamePart(TDes16& aName, const TUint8* aEntry, TInt aPos, TInt aOffset, TInt aLength)

// 

// Extract part of a long name entry into the name buffer.

//

// @param aName   buffer to put name