// 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_scn32dr1.cpp

// Tests that ScanDrive fixes known errors to a Rugged FAT drive

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "fat_utils.h"

using namespace Fat_Test_Utils;

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

/*

T_testscndrv tests the scandrive utility. Errors in this test will be

introduced using the RRawdDisk class.  The correct fixup is tested by rereading

the disk.  Drives tested are the default path(epoc) and X: (wins). This test

returns immediately if used on the internal ram drive

*/

/*

  The initial FAT12 directory structure (with cluster number in brackets) is as follows:

  |

   - scndrv (2)

        |

        - dir1 (3-4)

        |   |

        |   <a very long file name (19 entries)> (5)

        |

        - dir2 (6)

            |

            - full (7)

            |   |

            |   |

            |   - <seven 2*32 bytes entries> (11-17)

            |

            - somedirwith3entries (8)

            |

            - somedir2with3entries (9)

            |

            - almostfull(10)

                |

                - <two lots of 6*32 bytes entries> (18+19)

*/

/*

  The initial FAT32 directory structure (with cluster number in brackets is as follows):

  |

   - scndrv (3)

        |

        - dir1 (4)

        |   |

        |   <a very long file name (19 entries)> (5)

        |

        - dir2 (6)

            |

            - full (7)

            |   |

            |   |

            |   - <seven 2*32 bytes entries> (11-17)

            |

            - somedirwith3entries (8)

            |

            - somedir2with3entries (9)

            |

            - almostfull(10)

                |

                - <two lots of 6*32 bytes entries> (18+19)

*/

GLDEF_D RTest test(_L("T_SCN32DR1"));

LOCAL_D const TInt KMaxFatEntries  = 2048;

LOCAL_D const TInt KMaxFatSize     = KMaxFatEntries * 4;

LOCAL_D const TInt KDirAttrReadOnly  = 0x01;

LOCAL_D const TInt KDirAttrHidden    = 0x02;

LOCAL_D const TInt KDirAttrSystem    = 0x04;

LOCAL_D const TInt KDirAttrVolumeId  = 0x08;

LOCAL_D const TInt KDirAttrDirectory = 0x10;

LOCAL_D const TInt KDirAttrArchive   = 0x20;

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

LOCAL_D const TInt KDirAttrLongMask  = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;

LOCAL_D const TInt KDirLastLongEntry = 0x40;

LOCAL_D RRawDisk TheRawDisk;

LOCAL_D TFatBootSector BootSector;

LOCAL_D TFileName TheDrive=_L("?:\\");

LOCAL_D HBufC8* FatBufPtr = NULL;

LOCAL_D HBufC8* DirBufPtr = NULL;

LOCAL_D HBufC8* ExtBufPtr = NULL;

LOCAL_D TInt32  ExtBufAdd = 0;

LOCAL_D TInt32  ExtBufLen = 0;

LOCAL_D HBufC8* FatDiskPtr = NULL;

LOCAL_D HBufC8* DirDiskPtr = NULL;

static TFatType gDiskType = EInvalid;

LOCAL_D TInt gDriveNumber;

LOCAL_D TInt gBytesPerCluster;

LOCAL_D TInt gEntriesPerCluster;

LOCAL_D TInt gRootDirSectors;

LOCAL_D TInt gRootDirEntries;

LOCAL_D TInt gRootDirStart;      // in bytes

LOCAL_D TInt gRootSector;

LOCAL_D TInt gFatStartBytes;

LOCAL_D TInt gFatTestSize;       // in bytes

LOCAL_D TInt gFatTestEntries;

LOCAL_D TInt gFatSizeSectors;

LOCAL_D TInt gFirstDataSector;

LOCAL_D TInt gMaxDataCluster;

LOCAL_D TInt gDataStartBytes;

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

// cluster numbers in 1 and >1 sector per cluster modes

LOCAL_D TInt gClusterRootDir;        //  2    2

LOCAL_D TInt gClusterScnDrv;         //  3    3

LOCAL_D TInt gClusterDir1;           //  4    4

LOCAL_D TInt gClusterDir1ext;        //  5    4

LOCAL_D TInt gClusterDir2;           //  7    6

LOCAL_D TInt gClusterDir2_Full;      //  8    7

LOCAL_D TInt gClusterDir2_SD3E;      //  9    8

LOCAL_D TInt gClusterDir2_SD23E;     // 10    9

LOCAL_D TInt gClusterDir2_AFull;     // 11   10

LOCAL_D TInt gClusterEndMaxDepth;    // 147   146

LOCAL_D TFileName LastInFull;

class TEntryInfo

    {

public:

    TEntryInfo(TInt aBytePos,TInt aLength):iBytePos(aBytePos),iLength(aLength){}

    TEntryInfo(){}

public:

    TInt iBytePos;

    TInt iLength;

    };

LOCAL_C TInt DirBufferSize()

//

// returns size in bytes nec for buffer to store relevant disk data

//

    {

    return(gMaxDataCluster*gBytesPerCluster);

    }

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

    }

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

    if (aCluster < 2)

        pos = gRootDirStart;

    else

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

    return pos;

    }

LOCAL_C TInt ByteToCluster(TInt aBytePos)

//

// Converts byte offset from root dir buffer to cluster number

//

    {

    if (aBytePos < gRootDirStart)

        return -1;

    if (aBytePos < gDataStartBytes)

        return 0;

    return (aBytePos - gDataStartBytes) / gBytesPerCluster + 2;

    }

LOCAL_C TInt ClusterEntryToBytes(TInt aCluster,TInt aEntry)

//

// converts position in cluster and entry number to byte pos from root directory

//

    {

    TInt pos;

    pos = ClusterToByte(aCluster) - gRootDirStart + aEntry*KSizeOfFatDirEntry;

    return pos;

    }

LOCAL_C TInt FindUnMatch(const TUint8* aBuf, const TUint8* aCmp, TInt aLen, TInt aStart=0)

//

// Return position in buffers which doesn't match, or -1 if it matches

//

    {

    for (TInt i = aStart; i < aStart + aLen; i++)

        if (aBuf[i] != aCmp[i])

            return i;

    return -1;

    }

LOCAL_C 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 += BootSector.ReservedSectors() * BootSector.BytesPerSector();

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

        test_KErrNone(r);

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

        r=TheRawDisk.Read(pos, buf);

        test_KErrNone(r);

        TheRawDisk.Close();

        }

    TUint32 val = 0;

    switch (gDiskType)

        {

        case EFat32:

            val = ptr[0] + (ptr[1] << 8) + (ptr[2] << 16) + (ptr[3] << 24);

            break;

        case EFat16:

            val = ptr[0] + (ptr[1] << 8);

            break;

        case EFat12:

            val = ptr[0] + (ptr[1] << 8);

            if (aIndex & 1)

                    val >>= 4;

            val &= 0xFFF;

            break;

        default:

            test(0);

        }

    return val;

    }

LOCAL_C void WriteToFatBuf(TInt aFatIndex,TInt aValue,const TUint8* aFat)

//

// Write a value to both fats starting at aFat

//

    {

    TUint8* p=(TUint8*)(aFat+PosInBytes(aFatIndex));

    switch (gDiskType)

        {

        case EFat32:

            p[0] = (TUint8) (aValue);

            p[1] = (TUint8) (aValue >> 8);

            p[2] = (TUint8) (aValue >> 16);

            p[3] = (TUint8) (aValue >> 24);

            break;

        case EFat16:

            p[0] = (TUint8) (aValue);

            p[1] = (TUint8) (aValue >> 8);

            break;

        case EFat12:

            {

            TUint8 mask=0x0F;

            TBool odd=(aFatIndex)&1;

            TUint8 fatVal;

            TInt value=aValue;

            if(odd)

                {

                mask<<=4;

                value<<=4;

                fatVal=p[0];

                fatVal&=~mask;

                fatVal|=(TUint8)(value&0xFF);

                p[0]=fatVal;

                p[1]=(TUint8)(value>>8);

                }

            else

                {

                p[0]=(TUint8)(value&0xFF);

                fatVal=p[1];

                fatVal&=~mask;

                fatVal|=(TUint8)(value>>8);

                p[1]=fatVal;

                }

            }

            break;

        default:

            test(0);

        }

    return;

    }

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)

    if (BootSector.RootDirEntries() == 0)

        {

        test.Printf(_L("Disk is FAT32\n"));

        gDiskType = EFat32;

        gEndOfChain = 0x0FFFFFFF;

        }

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

        {

        test.Printf(_L("Disk is FAT16\n"));

        gDiskType = EFat16;

        gEndOfChain = 0xFFFF;

        }

    else

        {

        test.Printf(_L("Disk is FAT12\n"));

        gDiskType = EFat12;

        gEndOfChain = 0x0FFF;

        }

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

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

    gEntriesPerCluster = gBytesPerCluster / KSizeOfFatDirEntry;

    TBool big = (BootSector.SectorsPerCluster() > 1);

    switch (gDiskType)

        {

        case EFat12:

        case EFat16:

            gRootDirEntries     = BootSector.RootDirEntries();

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

            gFatSizeSectors     = BootSector.FatSectors();

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

            gFirstDataSector    = gRootSector + gRootDirSectors;

            gDataStartBytes     = gFirstDataSector * BootSector.BytesPerSector();

            gRootDirStart       = gRootSector * BootSector.BytesPerSector();

            gClusterRootDir     = (big ?   0 :   0);

            gClusterScnDrv      = (big ?   2 :   2);

            gClusterDir1        = (big ?   3 :   3);

            gClusterDir1ext     = (big ?   3 :   4);

            gClusterDir2        = (big ?   5 :   6);

            gClusterDir2_Full   = (big ?   6 :   7);

            gClusterDir2_SD3E   = (big ?   7 :   8);

            gClusterDir2_SD23E  = (big ?   8 :   9);

            gClusterDir2_AFull  = (big ?   9 :  10);

            gClusterEndMaxDepth = (big ? 145 : 146);

            break;

        case EFat32:

            //

            // FAT32 will alway pre-allocate a single cluster for the root directory

            //

            //  - The following calculations may look wierd (as the spec says that the FAT32 root dir

            //    is not fixed) but for the purposes of this test we assume that root dir is only

            //    one cluster in size, so we don't fill up the disk trying to fill up the root dir.

            //

            gRootDirEntries     = gBytesPerCluster * 1 / KSizeOfFatDirEntry;    // Maximum entries within default FAT32 root directory (before extension)

            gRootDirSectors     = 0;                                            // FAT32 has no fixed root directory sectors over which to skip

            gFatSizeSectors     = BootSector.FatSectors32();

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

            gFirstDataSector    = gRootSector;

            gDataStartBytes     = gFirstDataSector * BootSector.BytesPerSector();

            gRootDirStart       = (BootSector.RootClusterNum() - 2) * gBytesPerCluster + gDataStartBytes;

            gClusterRootDir     = (big ?   2 :   2);

            gClusterScnDrv      = (big ?   3 :   3);

            gClusterDir1        = (big ?   4 :   4);

            gClusterDir1ext     = (big ?   4 :   5);

            gClusterDir2        = (big ?   6 :   7);

            gClusterDir2_Full   = (big ?   7 :   8);

            gClusterDir2_SD3E   = (big ?   8 :   9);

            gClusterDir2_SD23E  = (big ?   9 :  10);

            gClusterDir2_AFull  = (big ?  10 :  11);

            gClusterEndMaxDepth = (big ? 146 : 147);

            break;

        default:

            break;

        }

    gMaxDataCluster = gClusterDir2_AFull + 2 + (gFirstDataSector / BootSector.SectorsPerCluster() + 1);

    gFatTestEntries = MaxClusters();

    if (gFatTestEntries > KMaxFatSize)

        gFatTestEntries = KMaxFatSize;

    }

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

    if (gDiskType == EFat32)

        {

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

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

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

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

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

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

        }

    }

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;

    LOCAL_D char const *   atr = "RHSVDA";

    str.Fill(TText('-'), 6);

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

        if ((aAttrib >> i) & 1)

            str[i] = atr[i];

    return &str;