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

// f32test\server\b_fat32.cpp

//

//

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include "fat_utils.h"

#include "t_server.h"

using namespace Fat_Test_Utils;

RTest test(_L("B_FAT32"));

static RRawDisk TheDisk;

static RFile TheFile;

static RDir TheDir;

static TEntry TheEntry;

static TFileName TheFileName;

static TBuf<16> TheDrive;

static HBufC8* pBuffer1=NULL;

static HBufC8* pBuffer2=NULL;

static TBuf8<0x800> TheBuffer;

static TEntry TheFileInfo;

static TVolumeInfo TheVolumeInfo;

static TBuf<8> ThePddName;

static TFatBootSector TheBootSector;

static  TInt64  rndSeed;

static  TFatType gDiskType = EInvalid;

static TInt gFatBits  = 0;

static TInt gBytesPerCluster;

static TInt gEntriesPerCluster;

static TInt gDataStartBytes;

static TInt gRootDirSectors;

static TInt gTotalSectors;

static TInt gRootDirStart;

static TInt gRootSector;

static TInt gRootCluster;

static TInt gFatTestEntries;

static TInt gFatSizeSectors;

static TInt gFirstDataSector;

static TInt gFirstDataCluster;

static TInt gClusterCount;

static TInt gEndOfChain;        // for FAT12/16/32

const TInt KMaxFatEntries  = 2048;

const TInt KMaxFatSize     = KMaxFatEntries * 4;

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;

void CreateFatEntry(const TDesC& aDir, TBool aVFatEntry, TDes *apFileName=NULL);

#define Error(aMess,aErr)  PutError(__FILE__, __LINE__, aMess,aErr)

static void PutError(const char* aFile, TInt aLine, const TDesC& aMessage,TInt anErr)

    {

    TFileName buf;

    TPtrC8 ptr((const TUint8*)aFile);

    buf.Copy(ptr);

    test.Printf(_L("%S failed - %d\n"), &aMessage,anErr);

    test.Printf(_L("In %S line %d\n"), &buf, aLine);

    test(0);

    }

//

// Position calculation and disk reading routines

// Return number of bytes into the FAT

static  TInt PosInBytes(TInt aFatIndex)

    {

    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  TUint32 MaxClusters()

    //

    // Return the number of data clusters on the disk

    //

    {

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

    TUint32 numSec = totSec - gFirstDataSector;

    return numSec / TheBootSector.SectorsPerCluster();

    }

static  TInt ClusterToByte(TInt aCluster)

    //

    // converts cluster number to byte offset on disk

    //

    {

    if (aCluster < 2)

        return gRootDirStart;

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

    return sector;

    }

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

//

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

//

    {

    TInt pos = PosInBytes(aIndex);

    TUint8  data[4];

    TUint8* ptr = data;

    if (aFat)

        ptr = (TUint8*)aFat + pos;

    else

        {

        pos += TheBootSector.ReservedSectors() * TheBootSector.BytesPerSector();

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

        test(r==KErrNone);

        TPtr8 buf(&data[0], 4);

        r=TheDisk.Read(pos, buf);

        test(r==KErrNone);

        TheDisk.Close();

        }

    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;

    }

 void MarkFatEntry(TUint32 aIndex)

//

// Marks a single FAT entry by modifying it's top 4 bits to

//

    {

    TInt pos = PosInBytes(aIndex);

    pos += TheBootSector.ReservedSectors() * TheBootSector.BytesPerSector();

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

    test(r==KErrNone);

    TUint8  data[4];

    TPtr8 buf(&data[0], 4);

    r=TheDisk.Read(pos, buf);

    test(r==KErrNone);

    data[3] &= 0x0F;

    data[3] |= 0xA0;

    r=TheDisk.Write(pos, buf);

    test(r==KErrNone);

    TheDisk.Close();

        }

 void DumpBootSector()

//

// Display (in log) TFatBootSector structure

//

    {

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

    RDebug::Print(_L("SectorsPerCluster = %8d (%d bytes)"),

                  TheBootSector.SectorsPerCluster(), gBytesPerCluster);

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

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

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

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

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

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

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

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

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

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

    //New for FAT32

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

        {

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

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

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

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

                      TheBootSector.RootClusterNum(),

                      gRootDirStart);

        RDebug::Print(_L("FSInfoSectorNum   = %8d (0x%08X)"),

                      TheBootSector.FSInfoSectorNum(),

                      TheBootSector.FSInfoSectorNum() * TheBootSector.BytesPerSector());

        RDebug::Print(_L("BkBootRecSector   = %8d (0x%08X)"),

                      TheBootSector.BkBootRecSector(),

                      TheBootSector.BkBootRecSector() * TheBootSector.BytesPerSector());

        }

    TInt fatEntries = gFatSizeSectors*TheBootSector.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 (%ld bytes)"), gClusterCount, ((TInt64)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);

    }

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

    }

 TDes* DirAttributes(TInt aAttrib)

//

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

//

    {

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

    static char*   atr = "RHSVDA";

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

        if ((aAttrib >> i) & 1)

            str[i] = atr[i];

    return &str;

    }

 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\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;

    }

 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;

    }

 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

// @param aEntry  directory entry raw data

// @param aPos    character in buffer to start name segment

// @param aOffset offset in directory entry of the segment

// @param aLength number of characters in the segment

//

    {

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

        {

        TInt at = i * 2 + aOffset;

        TInt ch = aEntry[at] + aEntry[at+1] * 256;

        aName[aPos++] = TText(ch);

        }

    }

 void ExtractNameString(TDes16& aName, const TUint8* aEntry)

//

// Extract a long name part from a directory entry, truncate it at the first

// NUL (0) character and put quotes round it.

//

    {

    aName.SetLength(15);

    TInt len = aName.Length() - 1;

    TText qu = '\'';

    aName[0] = qu;

    GetLongNamePart(aName, aEntry,  1,  1, 5);

    GetLongNamePart(aName, aEntry,  6, 14, 6);

    GetLongNamePart(aName, aEntry, 12, 28, 2);

    TInt i;

    for (i = 0; i < len; i++)

        if (aName[i] == 0)

            break;

    aName[i++] = qu;

    aName.SetLength(i);

    }

 TBool DumpDirEntry(TInt aNum, const TUint8* aEntry)

//

// Dump a single directory entry to the log.  Return false if it was end of

// directory or an invalid entry (and don't display it).

//

    {

    TFatDirEntry* d = (TFatDirEntry*)aEntry;

    if (d->IsErased())

        {

        // RDebug::Print(_L("%5d: ERASED"), aNum);

        }

    else if (d->IsEndOfDirectory())

        {

        RDebug::Print(_L("%5d: END-OF-DIRECTORY"), aNum);

        return EFalse;

        }

    else if ((d->Attributes() & KDirAttrLongMask) == KDirAttrLongName)

        {

        TBuf16<15> name;

        ExtractNameString(name, aEntry);

        TInt ord = aEntry[0];

        if (ord & KDirLastLongEntry)

            RDebug::Print(_L("%5d: %-15S #%-2d LAST"), aNum, &name, ord & ~KDirLastLongEntry);

        else

            RDebug::Print(_L("%5d: %-15S #%-2d"), aNum, &name, ord & ~KDirLastLongEntry);

        }

    else if (!IsValidDirEntry(d))

        {

        RDebug::Print(_L("%5d: not valid"), aNum);

        return EFalse;

        }

    else

        {

        TBuf<11> name;

        name.Copy(d->Name());

        RDebug::Print(_L("%5d: '%S'  %S  cluster %d"),

                      aNum, &name, DirAttributes(d->Attributes()), d->StartCluster());

        }

    return ETrue;

    }

 void DumpDirCluster(const TUint8* aData, TInt aCluster=0)

//

// Dump directory entries until end of cluster or invalid/end entry found.

//

    {

    if (aCluster > 2)

        aData += (aCluster-2) * gBytesPerCluster;

    for (TInt i = 0; i < gBytesPerCluster; i += KSizeOfFatDirEntry)

        {

        if (DumpDirEntry(i/KSizeOfFatDirEntry, aData))

            aData += KSizeOfFatDirEntry;

        else

            break;

        }

    }

 void DumpData(const TUint8* aFat, TInt aStart, TInt aEnd=-1)

//

// Dump clusters from disk (allows dumping of clusters not in our buffers).

// Only look at clusters marked as 'used' in the FAT.  Note that if aFat is

// NULL the FAT entries will also be read from disk (slower but allows for ones

// outside our copy in memory).

//

    {

    if (aStart > gFatTestEntries)

        return;

    if (aEnd > gFatTestEntries)

        aEnd = gFatTestEntries;

    if (aEnd <= 0)

        aEnd = aStart + 1;

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

    if (aEnd > gFatTestEntries)

        aEnd = gFatTestEntries;

    for (TInt cluster = aStart; cluster < aEnd; cluster++)

        {

        if (GetFatEntry(cluster, aFat) != 0)

            {

            HBufC8* buf=HBufC8::New(gBytesPerCluster);

            test(buf!=NULL);

            TPtr8 ptr=buf->Des();

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

            test(r==KErrNone);

            r=TheDisk.Read(ClusterToByte(cluster), ptr);

            test(r==KErrNone);

            TheDisk.Close();

            RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster));

            DumpDirCluster(ptr.Ptr());

            delete buf;

            }

        }

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

    }

 void DumpData(TInt aStart=0, TInt aEnd=0)

//

// Dump clusters from disk (allows dumping of clusters not in our buffers).

// Only look at clusters marked as 'used' in the FAT.  Note that if aFat is

// NULL the FAT entries will also be read from disk (slower but allows for ones

// outside our copy in memory).

//

    {

    if (aStart == 0)

        {

        if (aEnd <= 0)

            aEnd = 1;

        TInt num = (gDiskType == EFat32 ? aEnd*gEntriesPerCluster : TheBootSector.RootDirEntries());

        TInt pos = gRootDirStart;

        TInt ent = 0;

        HBufC8* buf=HBufC8::New(KSizeOfFatDirEntry);

        test(buf!=NULL);

        TPtr8 ptr=buf->Des();

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

        test(r==KErrNone);

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

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

            {

            r=TheDisk.Read(pos, ptr);

            test(r==KErrNone);

            if (!DumpDirEntry(ent, ptr.Ptr()))

                break;

            pos += KSizeOfFatDirEntry;

            }

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

        TheDisk.Close();

        delete buf;

        }

    else if (aStart == 1)

        {

        DumpData(0, 1);

        DumpData(NULL, gFirstDataCluster, aEnd);

        }

    else

        {

        DumpData(NULL, aStart, aEnd);

        }

    }

 void DumpHex(const TUint8* aData, TInt aLen)

//

// Dump a block of memory to the log in hex.