1 // Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // f32test\server\b_fat32.cpp

    15 //

    16 //

    17 

    18 #include <f32file.h>

    19 #include <e32test.h>

    20 #include <e32math.h>

    21 

    22 #include "fat_utils.h"

    23 #include "t_server.h"

    24 

    25 using namespace Fat_Test_Utils;

    26 

    27 

    28 RTest test(_L("B_FAT32"));

    29 

    30 static RRawDisk TheDisk;

    31 static RFile TheFile;

    32 static RDir TheDir;

    33 static TEntry TheEntry;

    34 static TFileName TheFileName;

    35 static TBuf<16> TheDrive;

    36 

    37 static HBufC8* pBuffer1=NULL;

    38 static HBufC8* pBuffer2=NULL;

    39 static TBuf8<0x800> TheBuffer;

    40 static TEntry TheFileInfo;

    41 static TVolumeInfo TheVolumeInfo;

    42 static TBuf<8> ThePddName;

    43 static TFatBootSector TheBootSector;

    44 

    45 static  TInt64  rndSeed;

    46 static  TFatType gDiskType = EInvalid;

    47 

    48 static TInt gFatBits  = 0;

    49 static TInt gBytesPerCluster;

    50 static TInt gEntriesPerCluster;

    51 static TInt gDataStartBytes;

    52 static TInt gRootDirSectors;

    53 static TInt gTotalSectors;

    54 static TInt gRootDirStart;

    55 static TInt gRootSector;

    56 static TInt gRootCluster;

    57 static TInt gFatTestEntries;

    58 static TInt gFatSizeSectors;

    59 static TInt gFirstDataSector;

    60 static TInt gFirstDataCluster;

    61 static TInt gClusterCount;

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

    63 

    64 const TInt KMaxFatEntries  = 2048;

    65 const TInt KMaxFatSize     = KMaxFatEntries * 4;

    66 const TInt KDirAttrReadOnly  = 0x01;

    67 const TInt KDirAttrHidden    = 0x02;

    68 const TInt KDirAttrSystem    = 0x04;

    69 const TInt KDirAttrVolumeId  = 0x08;

    70 const TInt KDirAttrDirectory = 0x10;

    71 const TInt KDirAttrArchive   = 0x20;

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

    73 const TInt KDirAttrLongMask  = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;

    74 const TInt KDirLastLongEntry = 0x40;

    75 

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

    77 

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

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

    80     {

    81     TFileName buf;

    82     TPtrC8 ptr((const TUint8*)aFile);

    83     buf.Copy(ptr);

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

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

    86     test(0);

    87     }

    88 

    89 

    90 //

    91 // Position calculation and disk reading routines

    92 // Return number of bytes into the FAT

    93 static  TInt PosInBytes(TInt aFatIndex)

    94     {

    95     TInt fatPosInBytes = -1;

    96     switch (gDiskType)

    97         {

    98         case EFat32:

    99             fatPosInBytes=aFatIndex<<2;

   100             break;

   101         case EFat16:

   102             fatPosInBytes=aFatIndex<<1;

   103             break;

   104         case EFat12:

   105             fatPosInBytes=(aFatIndex*3>>1);

   106             break;

   107         default:

   108             test(0);

   109         }

   110     return(fatPosInBytes);

   111     }

   112 

   113 static  TUint32 MaxClusters()

   114     //

   115     // Return the number of data clusters on the disk

   116     //

   117     {

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

   119     TUint32 numSec = totSec - gFirstDataSector;

   120     return numSec / TheBootSector.SectorsPerCluster();

   121     }

   122 

   123 static  TInt ClusterToByte(TInt aCluster)

   124     //

   125     // converts cluster number to byte offset on disk

   126     //

   127     {

   128     if (aCluster < 2)

   129         return gRootDirStart;

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

   131     return sector;

   132     }

   133 

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

   135 //

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

   137 //

   138     {

   139     TInt pos = PosInBytes(aIndex);

   140 

   141     TUint8  data[4];

   142     TUint8* ptr = data;

   143 

   144     if (aFat)

   145         ptr = (TUint8*)aFat + pos;

   146     else

   147         {

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

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

   150         test(r==KErrNone);

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

   152         r=TheDisk.Read(pos, buf);

   153         test(r==KErrNone);

   154         TheDisk.Close();

   155         }

   156 

   157     TUint32 val = 0;

   158     switch (gDiskType)

   159         {

   160         case EFat32:

   161             val = *(TUint32*)ptr;

   162             break;

   163         case EFat16:

   164             val = *(TUint16*)ptr;

   165             break;

   166         case EFat12:

   167             val = *(TUint16*)ptr;

   168             if (aIndex & 1)

   169                 val >>= 4;

   170             val &= 0xFFF;

   171             break;

   172         default:

   173             test(0);

   174         }

   175     return val;

   176     }

   177 

   178  void MarkFatEntry(TUint32 aIndex)

   179 //

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

   181 //

   182     {

   183     TInt pos = PosInBytes(aIndex);

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

   185 

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

   187     test(r==KErrNone);

   188     TUint8  data[4];

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

   190     r=TheDisk.Read(pos, buf);

   191     test(r==KErrNone);

   192     data[3] &= 0x0F;

   193     data[3] |= 0xA0;

   194     r=TheDisk.Write(pos, buf);

   195     test(r==KErrNone);

   196     TheDisk.Close();

   197         }

   198 

   199  void DumpBootSector()

   200 //

   201 // Display (in log) TFatBootSector structure

   202 //

   203     {

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

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

   206                   TheBootSector.SectorsPerCluster(), gBytesPerCluster);

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

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

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

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

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

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

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

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

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

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

   217 

   218     //New for FAT32

   219 

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

   221         {

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

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

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

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

   226                       TheBootSector.RootClusterNum(),

   227                       gRootDirStart);

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

   229                       TheBootSector.FSInfoSectorNum(),

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

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

   232                       TheBootSector.BkBootRecSector(),

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

   234         }

   235 

   236     TInt fatEntries = gFatSizeSectors*TheBootSector.BytesPerSector();

   237     switch (gDiskType)

   238     {

   239     case EFat32:

   240         fatEntries /= 4;

   241         break;

   242     case EFat16:

   243         fatEntries /= 2;

   244         break;

   245     case EFat12:

   246         fatEntries *= 3;

   247         fatEntries /= 2;

   248         break;

   249     default:

   250         test(0);

   251     }

   252 

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

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

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

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

   257     }

   258 

   259  void DumpFat(const TUint8* aFat=NULL)

   260 //

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

   262 //

   263     {

   264     TInt32 max = MaxClusters();

   265     if (max > KMaxFatEntries)

   266         max = KMaxFatEntries;

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

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

   269         {

   270         TInt32 val = GetFatEntry(i, aFat);

   271         TInt32 msk = 0x0FFFFFFF;

   272         switch (gDiskType)

   273             {

   274             case EFat32:

   275                 msk = 0x0FFFFFFF;

   276                 break;

   277             case EFat16:

   278                 msk = 0xFFFF;

   279                 break;

   280             case EFat12:

   281                 msk = 0x0FFF;

   282                 break;

   283             default:

   284                 test(0);

   285             }

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

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

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

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

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

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

   292         else if (val > max)

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

   294         else if (val != 0)

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

   296         }

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

   298     }

   299 

   300  TDes* DirAttributes(TInt aAttrib)

   301 //

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

   303 //

   304     {

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

   306     static char*   atr = "RHSVDA";

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

   308         if ((aAttrib >> i) & 1)

   309             str[i] = atr[i];

   310     return &str;

   311     }

   312 

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

   314 //

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

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

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

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

   319 //

   320     {

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

   322     if (aChar < aMin)

   323         return EFalse;

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

   325         if (aChar == *p)

   326             return EFalse;

   327     return ETrue;

   328     }

   329 

   330  TBool IsValidDirEntry(TFatDirEntry* aDir)

   331 //

   332 // Test whether buffer is a valid normal directory entry

   333 //

   334     {

   335     // top two bits of attributes must be zero

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

   337         return EFalse;

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

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

   340         return EFalse;

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

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

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

   344             return EFalse;

   345     return ETrue;

   346     }

   347 

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

   349 //

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

   351 //

   352 // @param aName   buffer to put name

   353 // @param aEntry  directory entry raw data

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

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

   356 // @param aLength number of characters in the segment

   357 //

   358     {

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

   360         {

   361         TInt at = i * 2 + aOffset;

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

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

   364         }

   365     }

   366 

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

   368 //

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

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

   371 //

   372     {

   373     aName.SetLength(15);

   374     TInt len = aName.Length() - 1;

   375     TText qu = '\'';

   376     aName[0] = qu;

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

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

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

   380     TInt i;

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

   382         if (aName[i] == 0)

   383             break;

   384     aName[i++] = qu;

   385     aName.SetLength(i);

   386     }

   387 

   388  TBool DumpDirEntry(TInt aNum, const TUint8* aEntry)

   389 //

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

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

   392 //

   393     {

   394     TFatDirEntry* d = (TFatDirEntry*)aEntry;

   395     if (d->IsErased())

   396         {

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

   398         }

   399     else if (d->IsEndOfDirectory())

   400         {

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

   402         return EFalse;

   403         }

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

   405         {

   406         TBuf16<15> name;

   407         ExtractNameString(name, aEntry);

   408         TInt ord = aEntry[0];

   409         if (ord & KDirLastLongEntry)

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

   411         else

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

   413         }

   414     else if (!IsValidDirEntry(d))

   415         {

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

   417         return EFalse;

   418         }

   419     else

   420         {

   421         TBuf<11> name;

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

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

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

   425         }

   426     return ETrue;

   427     }

   428 

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

   430 //

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

   432 //

   433     {

   434     if (aCluster > 2)

   435         aData += (aCluster-2) * gBytesPerCluster;

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

   437         {

   438         if (DumpDirEntry(i/KSizeOfFatDirEntry, aData))

   439             aData += KSizeOfFatDirEntry;

   440         else

   441             break;

   442         }

   443     }

   444 

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

   446 //

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

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

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

   450 // outside our copy in memory).

   451 //

   452     {

   453     if (aStart > gFatTestEntries)

   454         return;

   455     if (aEnd > gFatTestEntries)

   456         aEnd = gFatTestEntries;

   457     if (aEnd <= 0)

   458         aEnd = aStart + 1;

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

   460     if (aEnd > gFatTestEntries)

   461         aEnd = gFatTestEntries;

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

   463         {

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

   465             {

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

   467             test(buf!=NULL);

   468             TPtr8 ptr=buf->Des();

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

   470             test(r==KErrNone);

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

   472             test(r==KErrNone);

   473             TheDisk.Close();

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

   475             DumpDirCluster(ptr.Ptr());

   476             delete buf;

   477             }

   478         }

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

   480     }

   481 

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

   483 //

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

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

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

   487 // outside our copy in memory).

   488 //

   489     {

   490     if (aStart == 0)

   491         {

   492         if (aEnd <= 0)

   493             aEnd = 1;

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

   495         TInt pos = gRootDirStart;

   496         TInt ent = 0;

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

   498         test(buf!=NULL);

   499         TPtr8 ptr=buf->Des();

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

   501         test(r==KErrNone);

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

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

   504             {

   505             r=TheDisk.Read(pos, ptr);

   506             test(r==KErrNone);

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

   508                 break;

   509             pos += KSizeOfFatDirEntry;

   510             }

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

   512         TheDisk.Close();

   513         delete buf;

   514         }

   515     else if (aStart == 1)

   516         {

   517         DumpData(0, 1);

   518         DumpData(NULL, gFirstDataCluster, aEnd);

   519         }

   520     else

   521         {

   522         DumpData(NULL, aStart, aEnd);

   523         }

   524     }

   525 

   526  void DumpHex(const TUint8* aData, TInt aLen)

   527 //

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

   529 //

   530     {

   531     for (TInt base = 0; base < aLen; base += 16)

   532         {

   533         TBuf<16*3> buf;

   534         TInt off;

   535         for (off = base; off < aLen && off < base + 16; off++)

   536             {

   537             buf.Append(TText(' '));

   538             buf.AppendNumFixedWidth(aData[off], EHex, 2);

   539             }

   540         RDebug::Print(_L("%04X: %S"), base, &buf);

   541         }

   542     }

   543 

   544 

   545 //---------------------------------------------------------------------------------------------------------------

   546 

   547 static void DoReadBootSector(TFatBootSector& aBootSector)

   548 {

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

   550     test(nRes == KErrNone);

   551 

   552     if(!aBootSector.IsValid())

   553         {

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

   555         aBootSector.PrintDebugInfo();

   556         test(0);

   557         }

   558 

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

   560 

   561     if (TheBootSector.FatType() == EFat32)

   562         {

   563         gDiskType = EFat32;

   564         gFatBits  = 32;

   565         gEndOfChain = 0x0FFFFFFF;

   566         }

   567     else if (TheBootSector.FatType() == EFat16)

   568         {

   569         gDiskType = EFat16;

   570         gFatBits  = 16;

   571         gEndOfChain = 0xFFFF;

   572         }

   573     else

   574         {

   575         gDiskType = EFat12;

   576         gFatBits  = 12;

   577         gEndOfChain = 0x0FFF;

   578         }

   579 

   580     gBytesPerCluster   = TheBootSector.BytesPerSector() * TheBootSector.SectorsPerCluster();

   581     gRootDirSectors    = ((TheBootSector.RootDirEntries() * KSizeOfFatDirEntry + TheBootSector.BytesPerSector() - 1) /

   582                           TheBootSector.BytesPerSector());

   583     gEntriesPerCluster = gBytesPerCluster / KSizeOfFatDirEntry;

   584     gTotalSectors      = (TheBootSector.TotalSectors() ? TheBootSector.TotalSectors() : TheBootSector.HugeSectors());

   585 

   586     switch (gDiskType)

   587         {

   588         case EFat12:

   589         case EFat16:

   590             gFatSizeSectors   = TheBootSector.FatSectors();

   591             gRootSector       = TheBootSector.ReservedSectors() + TheBootSector.NumberOfFats() * gFatSizeSectors;

   592             gFirstDataSector  = gRootSector + gRootDirSectors;

   593             gRootCluster      = 0;

   594             gFirstDataCluster = 2;

   595             gDataStartBytes   = gFirstDataSector * TheBootSector.BytesPerSector();

   596             gRootDirStart     = gRootSector * TheBootSector.BytesPerSector();

   597             break;

   598         case EFat32:

   599             gFatSizeSectors   = TheBootSector.FatSectors32();

   600             gRootSector       = TheBootSector.ReservedSectors() + TheBootSector.NumberOfFats() * gFatSizeSectors;

   601             gFirstDataSector  = gRootSector + gRootDirSectors;

   602             gRootCluster      = 2;

   603             gFirstDataCluster = 3;

   604             gDataStartBytes   = gFirstDataSector * TheBootSector.BytesPerSector();

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

   606             break;

   607         default:

   608             break;

   609         }

   610 

   611     gClusterCount   = (gTotalSectors - gFirstDataSector) / TheBootSector.SectorsPerCluster();

   612 

   613     gFatTestEntries = MaxClusters();

   614     if (gFatTestEntries > KMaxFatSize)

   615         gFatTestEntries = KMaxFatSize;

   616     }

   617 

   618 

   619 static  TInt CalcShifts(TInt aSize)

   620 //

   621 // Calculate the number of shifts to get >= aSize (aSize should be a power of 2

   622 // anyway).

   623 //

   624     {

   625     TInt x=0;

   626     while (aSize>>=1)

   627         x++;

   628     return(x);

   629     }

   630 

   631 static  TInt SectorShifts()

   632 //

   633 // Calculate number of shifts for sector size.

   634 //

   635     {

   636     return(CalcShifts(TheBootSector.BytesPerSector()));

   637     }

   638 

   639 static  TInt ClusterShifts()

   640 //

   641 // Calculate number of shifts for cluster size.

   642 //

   643     {

   644     return(CalcShifts(TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()));

   645     }

   646 

   647 

   648 //

   649 // Quick Format the disk

   650 //

   651 static void FormatPack()

   652     {

   653 

   654     #if 0

   655     //-- FAT32 SPC:1; for the FAT32 testing on the emulator

   656     TFatFormatParam fp;

   657     fp.iFatType = EFat32;

   658     fp.iSecPerCluster = 1;

   659     FormatFatDrive(TheFs, CurrentDrive(), ETrue, &fp);

   660     #else

   661 

   662     FormatFatDrive(TheFs, CurrentDrive(), ETrue);

   663 

   664     #endif

   665 

   666     DoReadBootSector(TheBootSector);

   667 

   668     }

   669 

   670 

   671 

   672 static  void TestReadWrite(TInt64 aPos,TInt aLen,TInt anErr)

   673 //

   674 // Read and write to the disk

   675 //

   676     {

   677     TPtr8 buffer((TUint8*)pBuffer1->Ptr(),aLen);

   678     test.Printf(_L("TestReadWrite pos=0x%lx,len=%d\n"),aPos,aLen);

   679     TInt r;

   680     if ((r=TheDisk.Read(aPos,buffer))!=anErr)

   681         {

   682         test.Printf(_L("ERROR: anErr=%d ret=%d\n"),anErr,r);

   683         test(EFalse);

   684         }

   685     buffer.SetLength(aLen);

   686     if ((r=TheDisk.Write(aPos,buffer))!=anErr)

   687         {

   688         test.Printf(_L("ERROR: anErr=%d ret=%d\n"),anErr,r);

   689         test(EFalse);

   690         }

   691     }

   692 

   693 static  TInt ReadWriteWord(TInt64 aPos,TInt aMask,TInt aValue)

   694 //

   695 // Read 2 bytes from aPos and Write over masked bits with aValue

   696 //

   697     {

   698     TUint16 word;

   699     TPtr8 buffer((TUint8*)&word,sizeof(word));

   700 

   701     TInt r=TheDisk.Read(aPos,buffer);

   702     if (r!=KErrNone)

   703         return(r);

   704 

   705     word&=((aValue&aMask)|~aMask);

   706     word|=(aValue&aMask);

   707 

   708     r=TheDisk.Write(aPos,buffer);

   709     return(r);

   710     }

   711 

   712 static  TInt ReadWriteDWord(TInt64 aPos,TInt aMask,TInt aValue)

   713 //

   714 // Read 4 bytes from aPos and Write over masked bits with aValue

   715 //

   716     {

   717     TUint32 word;

   718     TPtr8 buffer((TUint8*)&word,sizeof(word));

   719 

   720     TInt r=TheDisk.Read(aPos,buffer);

   721     if (r!=KErrNone)

   722         return(r);

   723 

   724     word&=((aValue&aMask)|~aMask);

   725     word|=(aValue&aMask);

   726 

   727     r=TheDisk.Write(aPos,buffer);

   728     return(r);

   729     }

   730 

   731 static  void FatWrite(TInt aCluster,TInt aValue)

   732 //

   733 //

   734 //

   735     {

   736     TInt pos=0;

   737     TInt mask=0;

   738 

   739     const TUint32  KFirstFatSectorPos = TheBootSector.FirstFatSector() * TheBootSector.BytesPerSector();

   740 

   741     switch (gDiskType)

   742         {

   743         case EFat32:

   744             mask=0xffffffff;

   745             pos=KFirstFatSectorPos+(aCluster<<2);

   746             break;

   747         case EFat16:

   748             mask=0xffff;

   749             pos=KFirstFatSectorPos+(aCluster<<1);

   750             break;

   751         case EFat12:

   752             mask=0x0fff;

   753             pos=KFirstFatSectorPos+aCluster+(aCluster>>1);

   754             if (aCluster & 1)

   755                 {

   756                 mask=0xfff0;

   757                 aValue<<=4;

   758                 }

   759             break;

   760         default:

   761             test(0);

   762         }

   763 

   764     TInt r=TheDisk.Open(TheFs,CurrentDrive());

   765     test(r==KErrNone);

   766     test(ReadWriteDWord(pos,mask,aValue)==KErrNone);

   767     TheDisk.Close();

   768     }

   769 

   770 static  void TestRwWord(TInt64 aPos,TInt anErr)

   771 //

   772 //

   773 //

   774     {

   775     TInt r;

   776     TUint16 wBuf;

   777     TUint16 rBuf;

   778     TUint16 mask=0;

   779     TUint16 value=0;

   780 

   781     test.Printf(_L("Test read and write value to 0x%lx\n"),aPos);

   782 

   783     if ((r=ReadWriteWord(aPos,mask,value))!=anErr)

   784         {

   785         test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   786         test(EFalse);

   787         }

   788 

   789     if (anErr==KErrNone && aPos==0)

   790         {

   791         wBuf=0xff00;

   792         TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));

   793         test(TheDisk.Write(aPos,writebuf)==KErrNone);

   794 

   795         mask=0x0505;

   796         value=0xa4a4;

   797         test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);

   798         if ((r=ReadWriteWord(aPos,mask,value))!=anErr)

   799             {

   800             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   801             test(EFalse);

   802             }

   803 

   804         TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));

   805         if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)

   806             {

   807             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   808             test(EFalse);

   809             }

   810         test(rBuf==0xfe04);

   811         }

   812 

   813     if (anErr==KErrNone && aPos==1)

   814         {

   815         wBuf=0xff00;

   816         TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));

   817         test(TheDisk.Write(aPos,writebuf)==KErrNone);

   818 

   819         mask=0xffff;

   820         value=0xa3a3;

   821         test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);

   822         if ((r=ReadWriteWord(aPos,mask,value))!=anErr)

   823             {

   824             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   825             test(EFalse);

   826             }

   827 

   828         TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));

   829         if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)

   830             {

   831             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   832             test(EFalse);

   833             }

   834         test(rBuf==0xa3a3);

   835         }

   836     }

   837 

   838 static  void TestRwDWord(TInt64 aPos,TInt anErr)

   839 //

   840 //

   841 //

   842     {

   843     TInt r;

   844     TUint32 wBuf;

   845     TUint32 rBuf;

   846     TUint32 mask=0;

   847     TUint32 value=0;

   848 

   849     test.Printf(_L("Test read and write value to 0x%lx\n"),aPos);

   850 

   851     if ((r=ReadWriteDWord(aPos,mask,value))!=anErr)

   852         {

   853         test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   854         test(EFalse);

   855         }

   856 

   857     if (anErr==KErrNone && aPos==0)

   858         {

   859         wBuf=0xff00ff00;

   860         TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));

   861         test(TheDisk.Write(aPos,writebuf)==KErrNone);

   862 

   863         mask  = 0x0505195c;

   864         value = 0xa4a4c634;

   865         test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);

   866         if ((r=ReadWriteDWord(aPos,mask,value))!=anErr)

   867             {

   868             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   869             test(EFalse);

   870             }

   871 

   872         TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));

   873         if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)

   874             {

   875             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   876             test(EFalse);

   877             }

   878         test(rBuf==0xfe04e614);

   879         }

   880 

   881     if (anErr==KErrNone && aPos==1)

   882         {

   883         wBuf=0xff0000ff;

   884         TPtrC8 writebuf((TUint8*)&wBuf,sizeof(wBuf));

   885         test(TheDisk.Write(aPos,writebuf)==KErrNone);

   886 

   887         mask=0xffffffff;

   888         value=0xa3a3dead;

   889         test.Printf(_L("Test RWW mask=%04x value%04x\n"),mask,value);

   890         if ((r=ReadWriteDWord(aPos,mask,value))!=anErr)

   891             {

   892             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   893             test(EFalse);

   894             }

   895 

   896         TPtr8 readBuf((TUint8*)&rBuf,sizeof(rBuf));

   897         if ((r=TheDisk.Read(aPos,readBuf))!=KErrNone)

   898             {

   899             test.Printf(_L("ERROR: anErr=%d, ret=%d\n"),anErr,r);

   900             test(EFalse);

   901             }

   902         test(rBuf==0xa3a3dead);

   903         }

   904     }

   905 

   906 

   907 static  TInt ThrottleDirEntries(TInt aDirEntries, TInt aRemainder)

   908     {

   909     // throttle the number of entries needed, since for large cluster

   910     // sizes, this can take forever (eg 2GB card -> a cluster size of 32K

   911     // -> 1024 entries per cluster

   912     const TInt KMaxDirEntries = 2048;

   913     test(aRemainder < KMaxDirEntries);

   914     TInt maxDirEntries = KMaxDirEntries - aRemainder;

   915 

   916     if (aDirEntries > maxDirEntries)

   917         {

   918         RDebug::Print(_L("Reducing directory entries from %d to %d"), aDirEntries, maxDirEntries);

   919         aDirEntries = maxDirEntries;

   920         }

   921 

   922     return aDirEntries;

   923     }

   924 

   925 static  void TestLoopedSubDir()

   926 //

   927 //

   928     {

   929     test.Printf(_L("Test looped sub-dir\n"));

   930     FormatPack();

   931     TInt r=TheFs.MkDir(_L("\\D\\"));

   932     if (r!=KErrNone && r!=KErrAlreadyExists)

   933         Error(_L("Failed to make directory"),r);

   934     TheFileName=_L("\\D\\");

   935 

   936     TInt i=0;

   937     TInt dirEntriesNeeded = ((TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()/KSizeOfFatDirEntry)-2);

   938     dirEntriesNeeded = ThrottleDirEntries(dirEntriesNeeded, 2);

   939 

   940 

   941     //-- generate some number of VFAT dir. entries by creating  8.3 temp. files in a lower case

   942     for (i=0;i<dirEntriesNeeded;i++)

   943         {

   944         CreateFatEntry(TheFileName, ETrue);

   945         }

   946 

   947     test.Printf(_L("Test dir with no match\n"));

   948     FatWrite(gFirstDataCluster,gFirstDataCluster);

   949     if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)

   950         Error(_L("Failed Directory open"),r);

   951     if ((r=TheDir.Read(TheEntry))!=KErrCorrupt)

   952         Error(_L("Failed Directory read"),r);

   953     TheDir.Close();

   954 

   955     test.Printf(_L("Test dir with match\n"));

   956     if ((r=TheDir.Open(TheFs,_L("\\D\\*.*"),KEntryAttMaskSupported))!=KErrNone)

   957         Error(_L("Failed Directory open"),r);

   958     if ((r=TheDir.Read(TheEntry))!=KErrNone)

   959         Error(_L("Failed Directory read"),r);

   960     TheDir.Close();

   961 

   962     test.Printf(_L("Test dir without loop\n"));

   963     FatWrite(gFirstDataCluster,gEndOfChain);

   964     if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)

   965         Error(_L("Directory open"),r);

   966     if ((r=TheDir.Read(TheEntry))!=KErrEof)

   967         Error(_L("Reading empty dir returned"),r);

   968     TheDir.Close();

   969 

   970     test.Printf(_L("Test dir with long filenames\n"));

   971 

   972     FormatPack();

   973     r=TheFs.MkDir(_L("\\D\\"));

   974     if (r!=KErrNone && r!=KErrAlreadyExists)

   975         Error(_L("Failed to make directory"),r);

   976     TheFileName=_L("\\D\\");

   977 

   978     dirEntriesNeeded = ((TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()/KSizeOfFatDirEntry)-3);

   979     dirEntriesNeeded = ThrottleDirEntries(dirEntriesNeeded, 3);

   980 

   981     //-- generate some number of VFAT dir. entries by creating  8.3 temp. files in a lower case

   982     for (i=0;i<dirEntriesNeeded;i++)

   983         {

   984         CreateFatEntry(TheFileName, ETrue);

   985         }

   986 

   987     MakeFile(_L("\\D\\longfileName.Long"));

   988 

   989     test.Printf(_L("Test dir with no match\n"));

   990     FatWrite(gFirstDataCluster,gFirstDataCluster);

   991     if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)

   992         Error(_L("Failed Directory open"),r);

   993     if ((r=TheDir.Read(TheEntry))!=KErrCorrupt)

   994         Error(_L("Failed Directory read"),r);

   995     TheDir.Close();

   996 

   997     test.Printf(_L("Test dir with match\n"));

   998     if ((r=TheDir.Open(TheFs,_L("\\D\\*.*"),KEntryAttMaskSupported))!=KErrNone)

   999         Error(_L("Failed Directory open"),r);

  1000     if ((r=TheDir.Read(TheEntry))!=KErrNone)

  1001         Error(_L("Failed Directory read"),r);

  1002     TheDir.Close();

  1003 

  1004     test.Printf(_L("Test dir without loop\n"));

  1005     FatWrite(gFirstDataCluster,gEndOfChain);

  1006     if ((r=TheDir.Open(TheFs,_L("\\D\\nomatch"),KEntryAttMaskSupported))!=KErrNone)

  1007         Error(_L("Directory open"),r);

  1008 

  1009 #if !defined _UNICODE

  1010     if ((r=TheDir.Read(TheEntry))!=KErrCorrupt)

  1011         Error(_L("Reading empty dir returned"),r);

  1012 #endif

  1013     TheDir.Close();

  1014     }

  1015 

  1016 static  void TestLoopedFile()

  1017 //

  1018 // Test Looped file

  1019 //

  1020     {

  1021     test.Printf(_L("Test looped file\n"));

  1022     FormatPack();

  1023     TInt r;

  1024 

  1025 

  1026 

  1027     test.Next(_L("CreateFile"));

  1028     test(TheFile.Replace(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite)==KErrNone);

  1029     TPtr8 buf=pBuffer1->Des();

  1030 

  1031     test(TheFile.Write(buf,TheBootSector.BytesPerSector()-1)==KErrNone);

  1032     TheFile.Close();

  1033 

  1034     test.Next(_L("Write 1 cluster loop"));

  1035     FatWrite(gFirstDataCluster,gFirstDataCluster);              /* tiny loop */

  1036     if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)

  1037         Error(_L("Error opening corrupt file"),r);

  1038     FatWrite(gFirstDataCluster,0);

  1039     if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)

  1040         Error(_L("Error opening corrupt file"),r);

  1041     FatWrite(gFirstDataCluster,gEndOfChain);

  1042     if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrNone)

  1043         Error(_L("Error opening file"),r);

  1044     if ((r=TheFile.Write(buf,TheBootSector.BytesPerSector()*TheBootSector.SectorsPerCluster()*2-1))!=0)

  1045         Error(_L("Error writing to file"),r);

  1046     TheFile.Close();

  1047 

  1048     test.Next(_L("Write 2 cluster loop"));

  1049     FatWrite(gFirstDataCluster+1,gFirstDataCluster);             /* 2 cluster loop */

  1050     if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)

  1051         Error(_L("Error opening corrupt file"),r);

  1052     FatWrite(gFirstDataCluster+1,gEndOfChain);

  1053     if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrNone)

  1054         Error(_L("Error opening file"),r);

  1055 

  1056     TInt len=16384;

  1057     TInt size=0L;

  1058     while (size < gBytesPerCluster * 500)

  1059         {

  1060         test.Printf(_L("\rWriting %d      "),size);

  1061         if ((r=TheFile.Write(buf,len))!=KErrNone)

  1062             {

  1063             if (r!=KErrDiskFull)

  1064                 Error(_L("File write error"),r);

  1065             len>>=1;

  1066             if (len==0)

  1067                 break;

  1068             }

  1069         else

  1070         size+=len;

  1071         }

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

  1073     TheFile.Close();

  1074 

  1075     RDebug::Print(_L("File created size %d"), size);

  1076     TInt clust=((size-1)>>ClusterShifts())+gFirstDataCluster;

  1077     FatWrite(clust,gFirstDataCluster);

  1078     if ((r=TheFile.Open(TheFs,_L("\\LOOPED1.TMP"),EFileRead|EFileWrite))!=KErrCorrupt)

  1079         Error(_L("Error opening corrupt file"),r);

  1080     FatWrite(clust,gEndOfChain);

  1081     if ((r=TheFs.Delete(_L("\\LOOPED1.TMP")))!=KErrNone)

  1082         Error(_L("Error deleting file"),r);

  1083     RDebug::Print(_L("File removed"));

  1084     r=TheFs.CheckDisk(gSessionPath);

  1085     test(r==KErrNone);

  1086     }

  1087 

  1088 static  void TestFatEntry(TUint16 aFileSize,TInt aCorruptFatCluster)

  1089 //

  1090 // Test fat entry

  1091 //

  1092     {

  1093     TInt r;

  1094     test.Printf(_L("File size=%d, cluster value=0x%x\n"),aFileSize,aCorruptFatCluster);

  1095     FormatPack();

  1096 

  1097     r=TheFile.Replace(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);

  1098     test(r==KErrNone);

  1099     TheBuffer.SetLength(aFileSize);

  1100     Mem::Fill(&TheBuffer[0],aFileSize,'A');

  1101     r=TheFile.Write(TheBuffer);

  1102     test(r==KErrNone);

  1103     TheFile.Close();

  1104 

  1105     FatWrite(gFirstDataCluster,aCorruptFatCluster);

  1106 

  1107     TInt pos=0;

  1108     r=TheFile.Open(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);

  1109     test(r==KErrNone || r==KErrCorrupt);

  1110     if (r==KErrNone)

  1111         {

  1112         r=TheFile.Seek(ESeekStart,pos);

  1113         test(r==KErrNone);

  1114         r=TheFile.Write(TheBuffer);

  1115 

  1116         if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))

  1117             r = TheFile.Flush();

  1118 

  1119         if (r != KErrCorrupt)

  1120             {

  1121             test.Printf(_L("Predicted error %d Actual error %d\n"),KErrCorrupt,r);

  1122             Error(_L("Failed write"),r);

  1123             }

  1124         TheFile.Close();

  1125         }

  1126 

  1127     FatWrite(gFirstDataCluster,gEndOfChain);

  1128 

  1129     pos=0;

  1130     r=TheFile.Open(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);

  1131     test(r==KErrNone);

  1132     r=TheFile.Seek(ESeekStart,pos);

  1133     test(r==KErrNone);

  1134     r=TheFile.Write(TheBuffer);