1 // Copyright (c) 1998-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\scndrv\t_scn32dr1.cpp

    15 //

    16 //

    17 

    18 #include <f32file.h>

    19 #include <e32test.h>

    20 

    21 #include "t_server.h"

    22 

    23 #include "fat_utils.h"

    24 using namespace Fat_Test_Utils;

    25 

    26 #ifdef __VC32__

    27     // Solve compilation problem caused by non-English locale

    28     #pragma setlocale("english")

    29 #endif

    30 

    31 /*

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

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

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

    35 returns immediately if used on the internal ram drive

    36 */

    37 

    38 /*

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

    40 

    41   |

    42    - scndrv (2)

    43         |

    44         - dir1 (3-4)

    45         |   |

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

    47         |

    48         - dir2 (6)

    49             |

    50             - full (7)

    51             |   |

    52             |   |

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

    54             |

    55             - somedirwith3entries (8)

    56             |

    57             - somedir2with3entries (9)

    58             |

    59             - almostfull(10)

    60                 |

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

    62 

    63 */

    64 

    65 /*

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

    67 

    68   |

    69    - scndrv (3)

    70         |

    71         - dir1 (4)

    72         |   |

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

    74         |

    75         - dir2 (6)

    76             |

    77             - full (7)

    78             |   |

    79             |   |

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

    81             |

    82             - somedirwith3entries (8)

    83             |

    84             - somedir2with3entries (9)

    85             |

    86             - almostfull(10)

    87                 |

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

    89 

    90 */

    91 

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

    93 

    94 LOCAL_D const TInt KMaxFatEntries  = 2048;

    95 LOCAL_D const TInt KMaxFatSize     = KMaxFatEntries * 4;

    96 

    97 LOCAL_D const TInt KDirAttrReadOnly  = 0x01;

    98 LOCAL_D const TInt KDirAttrHidden    = 0x02;

    99 LOCAL_D const TInt KDirAttrSystem    = 0x04;

   100 LOCAL_D const TInt KDirAttrVolumeId  = 0x08;

   101 LOCAL_D const TInt KDirAttrDirectory = 0x10;

   102 LOCAL_D const TInt KDirAttrArchive   = 0x20;

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

   104 LOCAL_D const TInt KDirAttrLongMask  = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;

   105 LOCAL_D const TInt KDirLastLongEntry = 0x40;

   106 

   107 LOCAL_D RRawDisk TheRawDisk;

   108 LOCAL_D TFatBootSector BootSector;

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

   110 LOCAL_D HBufC8* FatBufPtr = NULL;

   111 LOCAL_D HBufC8* DirBufPtr = NULL;

   112 LOCAL_D HBufC8* ExtBufPtr = NULL;

   113 LOCAL_D TInt32  ExtBufAdd = 0;

   114 LOCAL_D TInt32  ExtBufLen = 0;

   115 LOCAL_D HBufC8* FatDiskPtr = NULL;

   116 LOCAL_D HBufC8* DirDiskPtr = NULL;

   117 

   118 static TFatType gDiskType = EInvalid;

   119 

   120 LOCAL_D TInt gDriveNumber;

   121 

   122 LOCAL_D TInt gBytesPerCluster;

   123 LOCAL_D TInt gEntriesPerCluster;

   124 LOCAL_D TInt gRootDirSectors;

   125 LOCAL_D TInt gRootDirEntries;

   126 LOCAL_D TInt gRootDirStart;      // in bytes

   127 LOCAL_D TInt gRootSector;

   128 LOCAL_D TInt gFatStartBytes;

   129 LOCAL_D TInt gFatTestSize;       // in bytes

   130 LOCAL_D TInt gFatTestEntries;

   131 LOCAL_D TInt gFatSizeSectors;

   132 LOCAL_D TInt gFirstDataSector;

   133 LOCAL_D TInt gMaxDataCluster;

   134 LOCAL_D TInt gDataStartBytes;

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

   136 

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

   138 LOCAL_D TInt gClusterRootDir;        //  2    2

   139 LOCAL_D TInt gClusterScnDrv;         //  3    3

   140 LOCAL_D TInt gClusterDir1;           //  4    4

   141 LOCAL_D TInt gClusterDir1ext;        //  5    4

   142 LOCAL_D TInt gClusterDir2;           //  7    6

   143 LOCAL_D TInt gClusterDir2_Full;      //  8    7

   144 LOCAL_D TInt gClusterDir2_SD3E;      //  9    8

   145 LOCAL_D TInt gClusterDir2_SD23E;     // 10    9

   146 LOCAL_D TInt gClusterDir2_AFull;     // 11   10

   147 LOCAL_D TInt gClusterEndMaxDepth;    // 147   146

   148 

   149 LOCAL_D TFileName LastInFull;

   150 

   151 class TEntryInfo

   152     {

   153 public:

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

   155     TEntryInfo(){}

   156 public:

   157     TInt iBytePos;

   158     TInt iLength;

   159     };

   160 

   161 

   162 LOCAL_C TInt DirBufferSize()

   163 //

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

   165 //

   166     {

   167     return(gMaxDataCluster*gBytesPerCluster);

   168     }

   169 

   170 LOCAL_C TInt PosInBytes(TInt aFatIndex)

   171 //

   172 // Return number of bytes into the FAT

   173 //

   174     {

   175     TInt fatPosInBytes = -1;

   176     switch (gDiskType)

   177         {

   178         case EFat32:

   179             fatPosInBytes=aFatIndex<<2;

   180             break;

   181         case EFat16:

   182             fatPosInBytes=aFatIndex<<1;

   183             break;

   184         case EFat12:

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

   186             break;

   187         default:

   188             test(0);

   189         }

   190     return(fatPosInBytes);

   191     }

   192 

   193 LOCAL_C TUint32 MaxClusters()

   194 //

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

   196 //

   197     {

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

   199     TUint32 numSec = totSec - gFirstDataSector;

   200     return numSec / BootSector.SectorsPerCluster();

   201     }

   202 

   203 LOCAL_C TInt ClusterToByte(TInt aCluster)

   204 //

   205 // converts cluster number to byte offset on disk

   206 //

   207     {

   208     TInt pos;

   209     if (aCluster < 2)

   210         pos = gRootDirStart;

   211     else

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

   213     return pos;

   214     }

   215 

   216 LOCAL_C TInt ByteToCluster(TInt aBytePos)

   217 //

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

   219 //

   220     {

   221     if (aBytePos < gRootDirStart)

   222         return -1;

   223     if (aBytePos < gDataStartBytes)

   224         return 0;

   225     return (aBytePos - gDataStartBytes) / gBytesPerCluster + 2;

   226     }

   227 

   228 LOCAL_C TInt ClusterEntryToBytes(TInt aCluster,TInt aEntry)

   229 //

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

   231 //

   232     {

   233     TInt pos;

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

   235     return pos;

   236     }

   237 

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

   239 //

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

   241 //

   242     {

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

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

   245             return i;

   246     return -1;

   247     }

   248 

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

   250 //

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

   252 //

   253     {

   254     TInt pos = PosInBytes(aIndex);

   255 

   256     TUint8  data[4];

   257     TUint8* ptr = data;

   258 

   259     if (aFat)

   260         ptr = (TUint8*)aFat + pos;

   261     else

   262         {

   263         pos += BootSector.ReservedSectors() * BootSector.BytesPerSector();

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

   265         test(r==KErrNone);

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

   267         r=TheRawDisk.Read(pos, buf);

   268         test(r==KErrNone);

   269         TheRawDisk.Close();

   270         }

   271 

   272     TUint32 val = 0;

   273     switch (gDiskType)

   274         {

   275         case EFat32:

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

   277             break;

   278         case EFat16:

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

   280             break;

   281         case EFat12:

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

   283             if (aIndex & 1)

   284                     val >>= 4;

   285             val &= 0xFFF;

   286             break;

   287         default:

   288             test(0);

   289         }

   290     return val;

   291     }

   292 

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

   294 //

   295 // Write a value to both fats starting at aFat

   296 //

   297     {

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

   299     switch (gDiskType)

   300         {

   301         case EFat32:

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

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

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

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

   306             break;

   307         case EFat16:

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

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

   310             break;

   311         case EFat12:

   312             {

   313             TUint8 mask=0x0F;

   314             TBool odd=(aFatIndex)&1;

   315             TUint8 fatVal;

   316             TInt value=aValue;

   317             if(odd)

   318                 {

   319                 mask<<=4;

   320                 value<<=4;

   321                 fatVal=p[0];

   322                 fatVal&=~mask;

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

   324                 p[0]=fatVal;

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

   326                 }

   327             else

   328                 {

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

   330                 fatVal=p[1];

   331                 fatVal&=~mask;

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

   333                 p[1]=fatVal;

   334                 }

   335             }

   336             break;

   337         default:

   338             test(0);

   339         }

   340     return;

   341     }

   342 

   343 static void DoReadBootSector()

   344     {

   345 

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

   347     test(nRes == KErrNone);

   348 

   349     if(!BootSector.IsValid())

   350         {

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

   352         BootSector.PrintDebugInfo();

   353         test(0);

   354         }

   355 

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

   357     if (BootSector.RootDirEntries() == 0)

   358         {

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

   360         gDiskType = EFat32;

   361         gEndOfChain = 0x0FFFFFFF;

   362         }

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

   364         {

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

   366         gDiskType = EFat16;

   367         gEndOfChain = 0xFFFF;

   368         }

   369     else

   370         {

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

   372         gDiskType = EFat12;

   373         gEndOfChain = 0x0FFF;

   374         }

   375 

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

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

   378     gEntriesPerCluster = gBytesPerCluster / KSizeOfFatDirEntry;

   379 

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

   381     switch (gDiskType)

   382         {

   383         case EFat12:

   384         case EFat16:

   385             gRootDirEntries     = BootSector.RootDirEntries();

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

   387             gFatSizeSectors     = BootSector.FatSectors();

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

   389             gFirstDataSector    = gRootSector + gRootDirSectors;

   390             gDataStartBytes     = gFirstDataSector * BootSector.BytesPerSector();

   391             gRootDirStart       = gRootSector * BootSector.BytesPerSector();

   392             gClusterRootDir     = (big ?   0 :   0);

   393             gClusterScnDrv      = (big ?   2 :   2);

   394             gClusterDir1        = (big ?   3 :   3);

   395             gClusterDir1ext     = (big ?   3 :   4);

   396             gClusterDir2        = (big ?   5 :   6);

   397             gClusterDir2_Full   = (big ?   6 :   7);

   398             gClusterDir2_SD3E   = (big ?   7 :   8);

   399             gClusterDir2_SD23E  = (big ?   8 :   9);

   400             gClusterDir2_AFull  = (big ?   9 :  10);

   401             gClusterEndMaxDepth = (big ? 145 : 146);

   402             break;

   403         case EFat32:

   404             //

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

   406             //

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

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

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

   410             //

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

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

   413             gFatSizeSectors     = BootSector.FatSectors32();

   414 

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

   416             gFirstDataSector    = gRootSector;

   417 

   418             gDataStartBytes     = gFirstDataSector * BootSector.BytesPerSector();

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

   420 

   421             gClusterRootDir     = (big ?   2 :   2);

   422             gClusterScnDrv      = (big ?   3 :   3);

   423             gClusterDir1        = (big ?   4 :   4);

   424             gClusterDir1ext     = (big ?   4 :   5);

   425             gClusterDir2        = (big ?   6 :   7);

   426             gClusterDir2_Full   = (big ?   7 :   8);

   427             gClusterDir2_SD3E   = (big ?   8 :   9);

   428             gClusterDir2_SD23E  = (big ?   9 :  10);

   429             gClusterDir2_AFull  = (big ?  10 :  11);

   430             gClusterEndMaxDepth = (big ? 146 : 147);

   431             break;

   432         default:

   433             break;

   434         }

   435 

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

   437 

   438     gFatTestEntries = MaxClusters();

   439     if (gFatTestEntries > KMaxFatSize)

   440         gFatTestEntries = KMaxFatSize;

   441     }

   442 

   443 

   444 GLDEF_C void DumpBootSector()

   445 //

   446 // Display (in log) TFatBootSector structure

   447 //

   448     {

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

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

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

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

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

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

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

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

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

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

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

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

   461 

   462     if (gDiskType == EFat32)

   463         {

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

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

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

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

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

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

   470         }

   471     }

   472 

   473 GLDEF_C void DumpFat(const TUint8* aFat=NULL)

   474 //

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

   476 //

   477     {

   478     TInt32 max = MaxClusters();

   479     if (max > KMaxFatEntries)

   480         max = KMaxFatEntries;

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

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

   483         {

   484         TInt32 val = GetFatEntry(i, aFat);

   485         TInt32 msk = 0x0FFFFFFF;

   486         switch (gDiskType)

   487             {

   488             case EFat32:

   489                 msk = 0x0FFFFFFF;

   490                 break;

   491             case EFat16:

   492                 msk = 0xFFFF;

   493                 break;

   494             case EFat12:

   495                 msk = 0x0FFF;

   496                 break;

   497             default:

   498                 test(0);

   499             }

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

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

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

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

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

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

   506         else if (val > max)

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

   508         else if (val != 0)

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

   510         }

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

   512     }

   513 

   514 GLDEF_C TDes* DirAttributes(TInt aAttrib)

   515 //

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

   517 //

   518     {

   519     LOCAL_D TBuf<6> str;

   520     LOCAL_D char*   atr = "RHSVDA";

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

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

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

   524             str[i] = atr[i];

   525     return &str;

   526     }

   527 

   528 GLDEF_C TBool IsValidDirEntry(TFatDirEntry* aDir)

   529 //

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

   531 //

   532     {

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

   534     if (aDir->iData[0] < 0x21 && aDir->iData[0] != 0x05)

   535         return EFalse;

   536     // other characters must be not less than space

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

   538         if (aDir->iData[i] < 0x20)

   539             return EFalse;

   540     return ETrue;

   541     }

   542 

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

   544 //

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

   546 //

   547 // @param aName   buffer to put name

   548 // @param aEntry  directory entry raw data

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

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

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

   552 //

   553     {

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

   555         {

   556         TInt at = i * 2 + aOffset;

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

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

   559         }

   560     }

   561 

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

   563 //

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

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

   566 //

   567     {

   568     aName.SetLength(15);

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

   570     TText qu = '\'';

   571     aName[0] = qu;

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

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

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

   575     TInt i;

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

   577         if (aName[i] == 0)

   578             break;

   579     aName[i++] = qu;

   580     aName.SetLength(i);

   581     }

   582 

   583 GLDEF_C TBool DumpDirEntry(TInt aNum, const TUint8* aEntry)

   584 //

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

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

   587 //

   588     {

   589     TFatDirEntry* d = (TFatDirEntry*)aEntry;

   590     if (d->IsErased())

   591         {

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

   593         }

   594     else if (d->IsEndOfDirectory())

   595         {

   596         if (aNum > 0)

   597             RDebug::Print(_L("%5d: ------------- end of directory"), aNum);

   598         return EFalse;

   599         }

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

   601         {

   602         TBuf16<15> name;

   603         ExtractNameString(name, aEntry);

   604         TInt ord = aEntry[0];

   605         if (ord & KDirLastLongEntry)

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

   607         else

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

   609         }

   610     else if (!IsValidDirEntry(d))

   611         {

   612         if (aNum > 0)

   613             RDebug::Print(_L("%5d: ============= INVALID ENTRY"), aNum);

   614         return EFalse;

   615         }

   616     else

   617         {

   618         TBuf<11> name;

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

   620         RDebug::Print(_L("%5d: '%S'   %S  start %-5d size %d"),

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

   622         }

   623     return ETrue;

   624     }

   625 

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

   627 //

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

   629 //

   630     {

   631     if (aCluster > 2)

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

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

   634         {

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

   636             aData += KSizeOfFatDirEntry;

   637         else

   638             break;

   639         }

   640     }

   641 

   642 GLDEF_C void DumpRootDir(const TUint8* aData)

   643 //

   644 // Dump the data area buffer, trying to interpret directory clusters (only look

   645 // at clusters which are marked as 'used' in the FAT).

   646 //

   647     {

   648     RDebug::Print(_L("Root dir @ 0x%08X:"), gRootDirStart);

   649     for (TInt i = 0; i < BootSector.RootDirEntries(); i++)

   650         {

   651         if (DumpDirEntry(i, aData))

   652             aData += KSizeOfFatDirEntry;

   653         else

   654             break;

   655         }

   656     }

   657 

   658 GLDEF_C void DumpData(const TUint8* aFat, const TUint8* aDir)

   659 //

   660 // Dump the data area buffer, trying to interpret directory clusters (only look

   661 // at clusters which are marked as 'used' in the FAT).

   662 //

   663     {

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

   665     if (gDiskType != EFat32)

   666         {

   667         DumpRootDir(aDir);

   668         }

   669     TInt max = (gFatTestEntries < gMaxDataCluster ? gFatTestEntries : gMaxDataCluster);

   670     for (TInt cluster = 2; cluster < max; cluster++)

   671         {

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

   673             {

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

   675             DumpDirCluster(aDir+gDataStartBytes-gRootDirStart, cluster);

   676             }

   677         }

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

   679     }

   680 

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

   682 //

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

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

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

   686 // outside our copy in memory).

   687 //

   688     {

   689     if (aStart > gFatTestEntries)

   690         return;

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

   692     if (aEnd > gFatTestEntries)

   693         aEnd = gFatTestEntries;

   694     if (aEnd < 0)

   695         aEnd = aStart + 1;

   696     if (aStart < 2 && gDiskType != EFat32)

   697         {

   698         HBufC8* buf=HBufC8::New(BootSector.RootDirEntries() * KSizeOfFatDirEntry);

   699         test(buf != NULL);

   700         TPtr8 ptr=buf->Des();

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

   702         test(r==KErrNone);

   703         r=TheRawDisk.Read(gRootDirStart, ptr);

   704         test(r==KErrNone);

   705         TheRawDisk.Close();

   706         DumpRootDir(buf->Ptr());

   707         delete(buf);

   708         aStart = 2;

   709         }

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

   711         {

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

   713             {

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

   715             test(buf!=NULL);

   716             TPtr8 ptr=buf->Des();

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

   718             test(r==KErrNone);

   719             r=TheRawDisk.Read(ClusterToByte(cluster), ptr);

   720             test(r==KErrNone);

   721             TheRawDisk.Close();

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

   723             DumpDirCluster(ptr.Ptr());

   724             delete buf;

   725             }

   726         }

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

   728     }

   729 

   730 GLDEF_C void DumpHex(const TUint8* aData, TInt aLen, TInt aBase=0)

   731 //

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

   733 //

   734     {

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

   736         {

   737         TBuf<16*3+3+16+1> buf;

   738         TInt off;

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

   740             {

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

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

   743             }

   744         buf.Append(_L("  |"));

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

   746             {

   747             TUint8 ch = aData[off];

   748             buf.Append(ch < 0x20 || ch > 0x7E ? TText('_') : TText(ch));

   749             }

   750         buf.Append(_L("|"));

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

   752         }

   753     }

   754 

   755 GLDEF_C void DumpHex(const TPtrC8& aData, TInt aLen, TInt aBase=0)

   756 //

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

   758 //

   759     {

   760     DumpHex(aData.Ptr(), aLen, aBase);

   761     }

   762 

   763 GLDEF_C void DumpHex(TInt aPos, TInt aLen, TInt aBase=0)

   764 //

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

   766 //

   767     {

   768     TPtr8 dirBuf=DirBufPtr->Des();

   769     DumpHex(dirBuf.Ptr()+aPos, aLen, aBase);

   770     }

   771 

   772 GLDEF_C void Dump(TEntryInfo& aEntry)

   773 //

   774 // Dump an entry description to the log in hex

   775 //

   776     {

   777     RDebug::Print(_L("--- TEntryInfo 0x%08X, %d"), aEntry.iBytePos, aEntry.iLength);

   778     TInt len = aEntry.iLength*KSizeOfFatDirEntry;

   779     DumpHex(aEntry.iBytePos, len, aEntry.iBytePos);

   780     }

   781 

   782 LOCAL_C TInt GetStartCluster(TInt aCluster, TInt aEntry)

   783 //

   784 // Get the start cluster pertaining to a directory entry in a specific

   785 // directory cluster, return -1 if not available (invalid entry).

   786 //

   787     {

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

   789     test(buf!=NULL);

   790     TPtr8 ptr=buf->Des();

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

   792     test(r==KErrNone);

   793     r=TheRawDisk.Read(ClusterToByte(aCluster), ptr);

   794     test(r==KErrNone);

   795     TheRawDisk.Close();

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

   797     TFatDirEntry* d = (TFatDirEntry*)ptr.Ptr() + aEntry;

   798     while ((d->Attributes() & KDirAttrLongMask) == KDirAttrLongName && aEntry < gEntriesPerCluster)

   799         {

   800         if (d->IsErased() || d->IsEndOfDirectory())

   801             break;

   802         ++aEntry;

   803         d = (TFatDirEntry*)ptr.Ptr() + aEntry;

   804         }

   805     TInt start = d->StartCluster();

   806     if (d->IsErased())

   807         start = -1;

   808     else if (d->IsEndOfDirectory())

   809         start = -1;

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

   811         start = -1;

   812     else if (!IsValidDirEntry(d))

   813         start = -1;

   814     delete buf;

   815     return start;

   816     }

   817 

   818 LOCAL_C void Format()

   819     {

   820     TInt nRes;

   821 

   822 #if 0

   823     TFatFormatParam fmt;

   824     fmt.iFatType = EFat32;

   825     fmt.iSecPerCluster = 1;

   826 

   827     nRes = FormatFatDrive(TheFs, CurrentDrive(), ETrue, &fmt);

   828 #else

   829     nRes = FormatFatDrive(TheFs, CurrentDrive(), ETrue);

   830 #endif

   831 

   832     test(nRes == KErrNone);

   833 

   834     }

   835 

   836 LOCAL_C void CreateDeepDir(TFileName& aDir,TInt aDepth)

   837 //

   838 // Increase directory strucutre by aDepth starting with aDir.

   839 //

   840     {

   841     TFileName num;

   842     num.Num(1);

   843     num+=_L("\\");

   844     TInt r;

   845     while(aDepth--)

   846         {

   847         num[0] = TText(aDepth % 26 + 'A');

   848         aDir+=num;

   849         r=TheFs.MkDir(aDir);

   850         test(r==KErrNone);

   851         }

   852     }

   853 

   854 LOCAL_C void DeleteDeepDir(TFileName& aDir,TInt aDepth)

   855 //

   856 // Delete dir structure.

   857 //

   858     {

   859     TInt r;

   860     while(aDepth--)

   861         {

   862         r=TheFs.RmDir(aDir);

   863         test(r==KErrNone);

   864         aDir.SetLength(aDir.Length()-2);

   865         }

   866     }

   867 

   868 LOCAL_C void CreateMaxDepthDir(TFileName& aDir1,TFileName& aDir2)

   869 //

   870 // Create directory structure with max possible depth-1.

   871 // Achieved by using dir names of one character.

   872 //

   873     {

   874     //create dir structure with depth of 25

   875     CreateDeepDir(aDir1,25);

   876     // split dir structure

   877     aDir2=aDir1;

   878     aDir2+=_L("a\\");

   879     TInt r=TheFs.MkDir(aDir2);

   880     test(r==KErrNone);

   881     // create dir with depth of 126 directories - one short of max depth

   882     CreateDeepDir(aDir1,101);

   883     // create dir with depth of 90

   884     CreateDeepDir(aDir2,64);

   885     }

   886 

   887 LOCAL_C void DeleteMaxDepthDir(TFileName&aDir1,TFileName&aDir2)

   888 //

   889 // Deletes max depth dir structure.

   890 //

   891     {

   892     DeleteDeepDir(aDir2,64);

   893     TInt r=TheFs.RmDir(aDir2);

   894     test(r==KErrNone);

   895     aDir2.SetLength(aDir2.Length()-2);

   896     DeleteDeepDir(aDir1,102);

   897     DeleteDeepDir(aDir1,24);

   898     }

   899 

   900 LOCAL_C void MakeVeryLongName(TFileName& aLong)

   901 //

   902 // appends a very long file name to aLong

   903 //

   904     {

   905     // create a name to take up 18 vfat entries - (1 sector + 2 entries)

   906     for(TInt i=0;i<234;++i)

   907         {

   908         TInt c='a'+i%26;

   909         aLong.Append(c);

   910         }

   911     }

   912 

   913 GLDEF_C void CreateLongNames(TFileName& aLong, TInt aClusters)

   914 //

   915 // Creates entries to fill up the number of directory clusters

   916 //

   917     {

   918     TInt len = aLong.Length(); // length of directory prefix

   919     MakeVeryLongName(aLong);

   920     TInt count = 0;

   921     RFile temp;

   922     for (TInt i = 0; i < aClusters * gEntriesPerCluster; i += 19)

   923         {

   924         aLong[len+0] = TText(count/26 + 'A');

   925         aLong[len+1] = TText(count%26 + 'A');

   926         count++;

   927         TInt r=temp.Create(TheFs,aLong,EFileShareAny);

   928         test(r==KErrNone);

   929         temp.Close();

   930         }

   931     }

   932 

   933 GLDEF_C void DeleteLongNames(TFileName& aLong, TInt aClusters)

   934 //

   935 // Deletes entries created by CreateLongNames()

   936 //

   937     {

   938     TInt len = aLong.Length(); // length of directory prefix

   939     MakeVeryLongName(aLong);

   940     TInt count = 0;

   941     for (TInt i = 0; i < aClusters * gEntriesPerCluster; i += 19)

   942         {

   943         aLong[len+0] = TText(count/26 + 'A');

   944         aLong[len+1] = TText(count%26 + 'A');

   945         count++;

   946         TInt r=TheFs.Delete(aLong);

   947         test(r==KErrNone || r==KErrNotFound);

   948         }

   949     }

   950 

   951 LOCAL_C void DeleteRootDir(TInt aNum=0)

   952 //

   953 // Delete all entries in the root directory up to the last - aNum

   954 //

   955     {

   956     test.Next(_L("Delete Root Directory Entries"));

   957     TInt maxRootEntries = gRootDirEntries;

   958     TFileName name=_L("\\???xxx");

   959     TInt count=0;

   960     TInt entriesSoFar=2;

   961     TInt r;

   962     count = 0;

   963     for (entriesSoFar=0; entriesSoFar<maxRootEntries - aNum; entriesSoFar+=2)

   964         {

   965         name[1]=(TUint16)(count/26/26+'a');

   966         name[2]=(TUint16)(count/26%26+'a');

   967         name[3]=(TUint16)(count%26+'a');

   968         r=TheFs.Delete(name);

   969         test(r==KErrNone || r==KErrNotFound);

   970         ++count;

   971         }

   972     }

   973 

   974 LOCAL_C void CreateRootDir()

   975 //

   976 // fill up root directory to 1 clusters by creating entries and then deleting

   977 // them except the last.

   978 //

   979     {

   980     test.Next(_L("Create Root Directory Entries"));

   981     TInt maxRootEntries = gRootDirEntries;

   982     TFileName name=_L("\\???xxx");

   983     TInt count=0;

   984     TInt entriesSoFar=2;

   985     TInt r;

   986     RFile f;

   987     for (entriesSoFar=0; entriesSoFar<maxRootEntries; entriesSoFar+=2)

   988         {

   989         name[1]=(TUint16)(count/26/26+'a');

   990         name[2]=(TUint16)(count/26%26+'a');

   991         name[3]=(TUint16)(count%26+'a');

   992         r=f.Create(TheFs, name, EFileWrite);

   993         test(r==KErrNone);

   994         f.Close();

   995         ++count;

   996         }

   997     DeleteRootDir(1);

   998     }

   999 

  1000 LOCAL_C void FillUpRootDir(TInt aFree=0)

  1001 //

  1002 // fill up root directory

  1003 //

  1004     {

  1005     TInt maxRootEntries = gRootDirEntries - aFree;

  1006     TFileName dir=_L("\\??\\");

  1007     TInt count=0;

  1008     TInt entriesSoFar=2;

  1009     TInt r;

  1010     while(entriesSoFar<maxRootEntries)

  1011         {

  1012         dir[1]=(TUint16)(count/26+'a');

  1013         dir[2]=(TUint16)(count%26+'a');

  1014         r=TheFs.MkDir(dir);

  1015         test(r==KErrNone);

  1016         entriesSoFar+=2;

  1017         ++count;

  1018         }

  1019     }

  1020 

  1021 LOCAL_C void UnFillUpRootDir(TInt aFree=0)

  1022 //

  1023 // reverse changes from FillUpRootDir()

  1024 //

  1025     {

  1026     TFileName dir=_L("\\??\\");

  1027     TInt entriesSoFar=gRootDirEntries-aFree;

  1028     TInt count=0;

  1029     TInt r;

  1030     while(entriesSoFar>2)

  1031         {

  1032         dir[1]=TUint16(count/26+'a');

  1033         dir[2]=TUint16(count%26+'a');

  1034         r=TheFs.RmDir(dir);

  1035         test(r==KErrNone);

  1036         entriesSoFar-=2;

  1037         ++count;

  1038         }

  1039     }

  1040 

  1041 LOCAL_C void DeleteDirectoryStructure()

  1042 //

  1043 // deletes the directory structure

  1044 //

  1045     {

  1046     test.Next(_L("Delete Directory Structure"));

  1047     TInt r=TheFs.RmDir(_L("\\scndrv\\dir2\\almostfull\\"));

  1048     test(r==KErrNone);

  1049     TInt entriesNeeded=(gEntriesPerCluster-2) / 2;  //7*2entries + . + .. = full sector

  1050     for (TInt i = 0; i < entriesNeeded; i++)

  1051         {

  1052         TFileName file=_L("\\scndrv\\dir2\\full\\__a");

  1053         file.AppendNum(i);

  1054         r=TheFs.Delete(file);

  1055         test(r==KErrNone||r==KErrNotFound);

  1056         }

  1057     r=TheFs.RmDir(_L("\\scndrv\\dir2\\full\\"));

  1058     test(r==KErrNone);

  1059     r=TheFs.RmDir(_L("\\scndrv\\dir2\\"));

  1060     test(r==KErrNone);

  1061     TFileName veryLongName=(_L("\\scndrv\\dir1\\"));

  1062     MakeVeryLongName(veryLongName);

  1063     r=TheFs.Delete(veryLongName);

  1064     test(r==KErrNone);

  1065     r=TheFs.RmDir(_L("\\scndrv\\dir1\\"));

  1066     test(r==KErrNone);

  1067     r=TheFs.RmDir(_L("\\scndrv\\"));

  1068     test(r==KErrNone);

  1069     }

  1070 

  1071 LOCAL_C void CreateDirectoryStructure()

  1072 //

  1073 // creates the directory structure

  1074 //

  1075     {

  1076     test.Next(_L("Create Directory Structure"));

  1077     // cluster 3 (root dir is cluster 2)

  1078     TInt r=TheFs.MkDir(_L("\\scndrv\\"));

  1079     test(r==KErrNone);

  1080     // cluster 4

  1081     r=TheFs.MkDir(_L("\\scndrv\\dir1\\"));

  1082     test(r==KErrNone);

  1083     TFileName veryLongName=(_L("\\scndrv\\dir1\\"));

  1084     MakeVeryLongName(veryLongName);

  1085     RFile f;

  1086     // cluster 5

  1087     r=f.Create(TheFs,veryLongName,EFileShareAny);

  1088     test(r==KErrNone);

  1089     r=f.SetSize(512);

  1090     test(r==KErrNone);

  1091     f.Close();

  1092     // cluster 6

  1093     r=TheFs.MkDir(_L("\\scndrv\\dir2\\"));

  1094     test(r==KErrNone);

  1095     // cluster 7

  1096     r=TheFs.MkDir(_L("\\scndrv\\dir2\\full\\"));

  1097     test(r==KErrNone);

  1098     // cluster 8

  1099     r=TheFs.MkDir(_L("\\scndrv\\dir2\\somedirwith3entries\\"));

  1100     test(r==KErrNone);

  1101     // cluster 9

  1102     r=TheFs.MkDir(_L("\\scndrv\\dir2\\somedir2with3entries\\"));

  1103     test(r==KErrNone);

  1104     // cluster 10

  1105     r=TheFs.MkDir(_L("\\scndrv\\dir2\\almostfull\\"));

  1106     test(r==KErrNone);

  1107     // cluster 11-17

  1108     TInt entriesNeeded=(gEntriesPerCluster-2) / 2;  //7*2entries + . + .. = full sector

  1109     for (TInt i = 0; i < entriesNeeded; i++)

  1110         {

  1111         TFileName file=_L("\\scndrv\\dir2\\full\\__a");

  1112         file.AppendNum(i);

  1113         LastInFull = file;

  1114         r=f.Create(TheFs,file,EFileShareAny);

  1115         test(r==KErrNone);

  1116         if (i < 7)

  1117             {

  1118             r=f.SetSize(512);

  1119             test(r==KErrNone);

  1120             }

  1121         f.Close();

  1122         }

  1123     // cluster 18-19

  1124     TInt charLength=13*4+1; // name to take up 6 entries

  1125     TFileName file1=_L("\\scndrv\\dir2\\almostfull\\");

  1126     while(charLength--)

  1127         {

  1128         TInt c='A'+charLength%26;

  1129         file1.Append(c);

  1130         }

  1131     TFileName file2=file1;

  1132     file1.AppendNum(1);

  1133     file2.AppendNum(2);

  1134     r=f.Create(TheFs,file1,EFileShareAny);