reactos/drivers/fs/vfat/fcb.c

   1 /*
   2  * FILE:             drivers/fs/vfat/fcb.c
   3  * PURPOSE:          Routines to manipulate FCBs.
   4  * COPYRIGHT:        See COPYING in the top level directory
   5  * PROJECT:          ReactOS kernel
   6  * PROGRAMMER:       Jason Filby (jasonfilby@yahoo.com)
   7  *                   Rex Jolliff (rex@lvcablemodem.com)
   8  *                   Hartmut Birr
   9  *                   Herve Poussineau (reactos@poussine.freesurf.fr)
  10  */
  11
  12 /*  -------------------------------------------------------  INCLUDES  */
  13
  14 #include <wctype.h> /* towlower prototype */
  15
  16 #define NDEBUG
  17 #include "vfat.h"
  18
  19 /*  --------------------------------------------------------  DEFINES  */
  20
  21 #define TAG_FCB TAG('V', 'F', 'C', 'B')
  22
  23 /*  --------------------------------------------------------  PUBLICS  */
  24
  25 ULONG vfatNameHash(ULONG hash, PUNICODE_STRING NameU)
  26 {
  27   PWCHAR last;
  28   PWCHAR curr;
  29   register WCHAR c;
  30
  31   ASSERT(NameU->Buffer[0] != L'.');
  32   curr = NameU->Buffer;
  33   last = NameU->Buffer + NameU->Length / sizeof(WCHAR);
  34
  35   while(curr < last)
  36     {
  37       c = towlower(*curr++);
  38       hash = (hash + (c << 4) + (c >> 4)) * 11;
  39     }
  40   return hash;
  41 }
  42
  43 VOID
  44 vfatSplitPathName(PUNICODE_STRING PathNameU, PUNICODE_STRING DirNameU, PUNICODE_STRING FileNameU)
  45 {
  46   PWCHAR pName;
  47   USHORT Length = 0;
  48   pName = PathNameU->Buffer + PathNameU->Length / sizeof(WCHAR) - 1;
  49   while (*pName != L'\\' && pName >= PathNameU->Buffer)
  50     {
  51       pName--;
  52       Length++;
  53     }
  54   ASSERT(*pName == L'\\' || pName < PathNameU->Buffer);
  55   if (FileNameU)
  56     {
  57       FileNameU->Buffer = pName + 1;
  58       FileNameU->Length = FileNameU->MaximumLength = Length * sizeof(WCHAR);
  59     }
  60   if (DirNameU)
  61     {
  62       DirNameU->Buffer = PathNameU->Buffer;
  63       DirNameU->Length = (pName + 1 - PathNameU->Buffer) * sizeof(WCHAR);
  64       DirNameU->MaximumLength = DirNameU->Length;
  65     }
  66 }
  67
  68 VOID
  69 vfatInitFcb(PVFATFCB Fcb, PUNICODE_STRING NameU)
  70 {
  71   USHORT PathNameBufferLength;
  72
  73   if (NameU)
  74     PathNameBufferLength = NameU->Length + sizeof(WCHAR);
  75   else
  76     PathNameBufferLength = 0;
  77
  78   Fcb->PathNameBuffer = ExAllocatePool(NonPagedPool, PathNameBufferLength);
  79   if (!Fcb->PathNameBuffer)
  80   {
  81     /* FIXME: what to do if no more memory? */
  82     DPRINT1("Unable to initialize FCB for filename '%wZ'\n", NameU);
  83     KEBUGCHECKEX(0, (ULONG_PTR)Fcb, (ULONG_PTR)NameU, 0, 0);
  84   }
  85
  86   Fcb->PathNameU.Length = 0;
  87   Fcb->PathNameU.Buffer = Fcb->PathNameBuffer;
  88   Fcb->PathNameU.MaximumLength = PathNameBufferLength;
  89   Fcb->ShortNameU.Length = 0;
  90   Fcb->ShortNameU.Buffer = Fcb->ShortNameBuffer;
  91   Fcb->ShortNameU.MaximumLength = sizeof(Fcb->ShortNameBuffer);
  92   Fcb->DirNameU.Buffer = Fcb->PathNameU.Buffer;
  93   if (NameU && NameU->Length)
  94     {
  95       RtlCopyUnicodeString(&Fcb->PathNameU, NameU);
  96       vfatSplitPathName(&Fcb->PathNameU, &Fcb->DirNameU, &Fcb->LongNameU);
  97     }
  98   else
  99     {
 100       Fcb->DirNameU.Buffer = Fcb->LongNameU.Buffer = NULL;
 101       Fcb->DirNameU.MaximumLength = Fcb->DirNameU.Length = 0;
 102       Fcb->LongNameU.MaximumLength = Fcb->LongNameU.Length = 0;
 103     }
 104   RtlZeroMemory(&Fcb->FCBShareAccess, sizeof(SHARE_ACCESS));
 105   Fcb->OpenHandleCount = 0;
 106 }
 107
 108 PVFATFCB
 109 vfatNewFCB(PDEVICE_EXTENSION  pVCB, PUNICODE_STRING pFileNameU)
 110 {
 111   PVFATFCB  rcFCB;
 112
 113   DPRINT("'%wZ'\n", pFileNameU);
 114
 115   rcFCB = ExAllocateFromNPagedLookasideList(&VfatGlobalData->FcbLookasideList);
 116   if (rcFCB == NULL)
 117     {
 118       return NULL;
 119     }
 120   RtlZeroMemory(rcFCB, sizeof(VFATFCB));
 121   vfatInitFcb(rcFCB, pFileNameU);
 122   if (pVCB->Flags & VCB_IS_FATX)
 123   {
 124     rcFCB->Flags |= FCB_IS_FATX_ENTRY;
 125     rcFCB->Attributes = &rcFCB->entry.FatX.Attrib;
 126   }
 127   else
 128     rcFCB->Attributes = &rcFCB->entry.Fat.Attrib;
 129   rcFCB->Hash.Hash = vfatNameHash(0, &rcFCB->PathNameU);
 130   rcFCB->Hash.self = rcFCB;
 131   rcFCB->ShortHash.self = rcFCB;
 132   ExInitializeResourceLite(&rcFCB->PagingIoResource);
 133   ExInitializeResourceLite(&rcFCB->MainResource);
 134   FsRtlInitializeFileLock(&rcFCB->FileLock, NULL, NULL);
 135   ExInitializeFastMutex(&rcFCB->LastMutex);
 136   rcFCB->RFCB.PagingIoResource = &rcFCB->PagingIoResource;
 137   rcFCB->RFCB.Resource = &rcFCB->MainResource;
 138   rcFCB->RFCB.IsFastIoPossible = FastIoIsNotPossible;
 139
 140   return  rcFCB;
 141 }
 142
 143 VOID
 144 vfatDestroyCCB(PVFATCCB pCcb)
 145 {
 146   if (pCcb->SearchPattern.Buffer)
 147     {
 148       ExFreePool(pCcb->SearchPattern.Buffer);
 149     }
 150   ExFreeToNPagedLookasideList(&VfatGlobalData->CcbLookasideList, pCcb);
 151 }
 152
 153 VOID
 154 vfatDestroyFCB(PVFATFCB pFCB)
 155 {
 156   FsRtlUninitializeFileLock(&pFCB->FileLock);
 157   ExFreePool(pFCB->PathNameBuffer);
 158   ExDeleteResourceLite(&pFCB->PagingIoResource);
 159   ExDeleteResourceLite(&pFCB->MainResource);
 160   ExFreeToNPagedLookasideList(&VfatGlobalData->FcbLookasideList, pFCB);
 161 }
 162
 163 BOOLEAN
 164 vfatFCBIsDirectory(PVFATFCB FCB)
 165 {
 166   return  *FCB->Attributes & FILE_ATTRIBUTE_DIRECTORY;
 167 }
 168
 169 BOOLEAN
 170 vfatFCBIsRoot(PVFATFCB FCB)
 171 {
 172   return  FCB->PathNameU.Length == sizeof(WCHAR) && FCB->PathNameU.Buffer[0] == L'\\' ? TRUE : FALSE;
 173 }
 174
 175 VOID
 176 vfatReleaseFCB(PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
 177 {
 178   HASHENTRY* entry;
 179   ULONG Index;
 180   ULONG ShortIndex;
 181   PVFATFCB tmpFcb;
 182
 183   DPRINT ("releasing FCB at %x: %wZ, refCount:%d\n",
 184           pFCB,
 185           &pFCB->PathNameU,
 186           pFCB->RefCount);
 187
 188   while (pFCB)
 189   {
 190      Index = pFCB->Hash.Hash % pVCB->HashTableSize;
 191      ShortIndex = pFCB->ShortHash.Hash % pVCB->HashTableSize;
 192      pFCB->RefCount--;
 193      if (pFCB->RefCount == 0)
 194      {
 195         tmpFcb = pFCB->parentFcb;
 196         RemoveEntryList (&pFCB->FcbListEntry);
 197         if (pFCB->Hash.Hash != pFCB->ShortHash.Hash)
 198         {
 199            entry = pVCB->FcbHashTable[ShortIndex];
 200            if (entry->self == pFCB)
 201            {
 202               pVCB->FcbHashTable[ShortIndex] = entry->next;
 203            }
 204            else
 205            {
 206               while (entry->next->self != pFCB)
 207               {
 208                  entry = entry->next;
 209               }
 210               entry->next = pFCB->ShortHash.next;
 211            }
 212         }
 213         entry = pVCB->FcbHashTable[Index];
 214         if (entry->self == pFCB)
 215         {
 216            pVCB->FcbHashTable[Index] = entry->next;
 217         }
 218         else
 219         {
 220            while (entry->next->self != pFCB)
 221            {
 222               entry = entry->next;
 223            }
 224            entry->next = pFCB->Hash.next;
 225         }
 226         vfatDestroyFCB (pFCB);
 227      }
 228      else
 229      {
 230         tmpFcb = NULL;
 231      }
 232      pFCB = tmpFcb;
 233   }
 234 }
 235
 236 VOID
 237 vfatAddFCBToTable(PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
 238 {
 239   ULONG Index;
 240   ULONG ShortIndex;
 241
 242   Index = pFCB->Hash.Hash % pVCB->HashTableSize;
 243   ShortIndex = pFCB->ShortHash.Hash % pVCB->HashTableSize;
 244
 245   InsertTailList (&pVCB->FcbListHead, &pFCB->FcbListEntry);
 246
 247   pFCB->Hash.next = pVCB->FcbHashTable[Index];
 248   pVCB->FcbHashTable[Index] = &pFCB->Hash;
 249   if (pFCB->Hash.Hash != pFCB->ShortHash.Hash)
 250   {
 251      pFCB->ShortHash.next = pVCB->FcbHashTable[ShortIndex];
 252      pVCB->FcbHashTable[ShortIndex] = &pFCB->ShortHash;
 253   }
 254   if (pFCB->parentFcb)
 255   {
 256      pFCB->parentFcb->RefCount++;
 257   }
 258 }
 259
 260 PVFATFCB
 261 vfatGrabFCBFromTable(PDEVICE_EXTENSION  pVCB, PUNICODE_STRING  PathNameU)
 262 {
 263   PVFATFCB  rcFCB;
 264   ULONG Hash;
 265   UNICODE_STRING DirNameU;
 266   UNICODE_STRING FileNameU;
 267   PUNICODE_STRING FcbNameU;
 268
 269   HASHENTRY* entry;
 270
 271   DPRINT("'%wZ'\n", PathNameU);
 272
 273   Hash = vfatNameHash(0, PathNameU);
 274
 275   entry = pVCB->FcbHashTable[Hash % pVCB->HashTableSize];
 276   if (entry)
 277     {
 278       vfatSplitPathName(PathNameU, &DirNameU, &FileNameU);
 279     }
 280
 281   while (entry)
 282     {
 283       if (entry->Hash == Hash)
 284         {
 285           rcFCB = entry->self;
 286           DPRINT("'%wZ' '%wZ'\n", &DirNameU, &rcFCB->DirNameU);
 287           if (RtlEqualUnicodeString(&DirNameU, &rcFCB->DirNameU, TRUE))
 288             {
 289               if (rcFCB->Hash.Hash == Hash)
 290                 {
 291                   FcbNameU = &rcFCB->LongNameU;
 292                 }
 293               else
 294                 {
 295                   FcbNameU = &rcFCB->ShortNameU;
 296                 }
 297               /* compare the file name */
 298               DPRINT("'%wZ' '%wZ'\n", &FileNameU, FcbNameU);
 299               if (RtlEqualUnicodeString(&FileNameU, FcbNameU, TRUE))
 300                 {
 301                   rcFCB->RefCount++;
 302                   CHECKPOINT;
 303                   return rcFCB;
 304                 }
 305             }
 306         }
 307      entry = entry->next;
 308   }
 309   CHECKPOINT;
 310   return  NULL;
 311 }
 312
 313 NTSTATUS
 314 vfatFCBInitializeCacheFromVolume (PVCB  vcb, PVFATFCB  fcb)
 315 {
 316 #ifdef USE_ROS_CC_AND_FS
 317   NTSTATUS  status;
 318   ULONG  fileCacheQuantum;
 319 #endif
 320   PFILE_OBJECT  fileObject;
 321   PVFATCCB  newCCB;
 322
 323   fileObject = IoCreateStreamFileObject (NULL, vcb->StorageDevice);
 324
 325   newCCB = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
 326   if (newCCB == NULL)
 327   {
 328     return  STATUS_INSUFFICIENT_RESOURCES;
 329   }
 330   RtlZeroMemory(newCCB, sizeof (VFATCCB));
 331
 332   fileObject->SectionObjectPointer = &fcb->SectionObjectPointers;
 333   fileObject->FsContext = fcb;
 334   fileObject->FsContext2 = newCCB;
 335   fcb->FileObject = fileObject;
 336   fcb->RefCount++;
 337
 338 #ifdef USE_ROS_CC_AND_FS
 339   fileCacheQuantum = (vcb->FatInfo.BytesPerCluster >= PAGE_SIZE) ?
 340       vcb->FatInfo.BytesPerCluster : PAGE_SIZE;
 341
 342   status = CcRosInitializeFileCache (fileObject,
 343                                      fileCacheQuantum);
 344   if (!NT_SUCCESS (status))
 345   {
 346     DbgPrint ("CcRosInitializeFileCache failed\n");
 347     KEBUGCHECK (0);
 348   }
 349 #else
 350   /* FIXME: Guard by SEH. */
 351   CcInitializeCacheMap(fileObject,
 352                        (PCC_FILE_SIZES)(&fcb->RFCB.AllocationSize),
 353                        FALSE,
 354                        &VfatGlobalData->CacheMgrCallbacks,
 355                        fcb);
 356 #endif
 357
 358   fcb->Flags |= FCB_CACHE_INITIALIZED;
 359   return STATUS_SUCCESS;
 360 }
 361
 362 PVFATFCB
 363 vfatMakeRootFCB(PDEVICE_EXTENSION  pVCB)
 364 {
 365   PVFATFCB  FCB;
 366   ULONG FirstCluster, CurrentCluster, Size = 0;
 367   NTSTATUS Status = STATUS_SUCCESS;
 368   UNICODE_STRING NameU = RTL_CONSTANT_STRING(L"\\");
 369
 370   FCB = vfatNewFCB(pVCB, &NameU);
 371   if (FCB->Flags & FCB_IS_FATX_ENTRY)
 372   {
 373     memset(FCB->entry.FatX.Filename, ' ', 42);
 374     FCB->entry.FatX.FileSize = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
 375     FCB->entry.FatX.Attrib = FILE_ATTRIBUTE_DIRECTORY;
 376     FCB->entry.FatX.FirstCluster = 1;
 377     Size = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
 378   }
 379   else
 380   {
 381     memset(FCB->entry.Fat.ShortName, ' ', 11);
 382     FCB->entry.Fat.FileSize = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
 383     FCB->entry.Fat.Attrib = FILE_ATTRIBUTE_DIRECTORY;
 384     if (pVCB->FatInfo.FatType == FAT32)
 385     {
 386       CurrentCluster = FirstCluster = pVCB->FatInfo.RootCluster;
 387       FCB->entry.Fat.FirstCluster = (unsigned short)(FirstCluster & 0xffff);
 388       FCB->entry.Fat.FirstClusterHigh = (unsigned short)(FirstCluster >> 16);
 389
 390       while (CurrentCluster != 0xffffffff && NT_SUCCESS(Status))
 391       {
 392         Size += pVCB->FatInfo.BytesPerCluster;
 393         Status = NextCluster (pVCB, FirstCluster, &CurrentCluster, FALSE);
 394       }
 395     }
 396     else
 397     {
 398       FCB->entry.Fat.FirstCluster = 1;
 399       Size = pVCB->FatInfo.rootDirectorySectors * pVCB->FatInfo.BytesPerSector;
 400     }
 401   }
 402   FCB->ShortHash.Hash = FCB->Hash.Hash;
 403   FCB->RefCount = 2;
 404   FCB->dirIndex = 0;
 405   FCB->RFCB.FileSize.QuadPart = Size;
 406   FCB->RFCB.ValidDataLength.QuadPart = Size;
 407   FCB->RFCB.AllocationSize.QuadPart = Size;
 408   FCB->RFCB.IsFastIoPossible = FastIoIsNotPossible;
 409
 410   vfatFCBInitializeCacheFromVolume(pVCB, FCB);
 411   vfatAddFCBToTable(pVCB, FCB);
 412
 413   return(FCB);
 414 }
 415
 416 PVFATFCB
 417 vfatOpenRootFCB(PDEVICE_EXTENSION  pVCB)
 418 {
 419   PVFATFCB  FCB;
 420   UNICODE_STRING NameU = RTL_CONSTANT_STRING(L"\\");
 421
 422   FCB = vfatGrabFCBFromTable (pVCB, &NameU);
 423   if (FCB == NULL)
 424   {
 425     FCB = vfatMakeRootFCB (pVCB);
 426   }
 427
 428   return  FCB;
 429 }
 430
 431 NTSTATUS
 432 vfatMakeFCBFromDirEntry(PVCB  vcb,
 433                         PVFATFCB  directoryFCB,
 434                         PVFAT_DIRENTRY_CONTEXT DirContext,
 435                         PVFATFCB* fileFCB)
 436 {
 437   PVFATFCB  rcFCB;
 438   PWCHAR PathNameBuffer;
 439   USHORT PathNameLength;
 440   ULONG Size;
 441   ULONG hash;
 442
 443   UNICODE_STRING NameU;
 444
 445   PathNameLength = directoryFCB->PathNameU.Length + max(DirContext->LongNameU.Length, DirContext->ShortNameU.Length);
 446   if (!vfatFCBIsRoot (directoryFCB))
 447   {
 448      PathNameLength += sizeof(WCHAR);
 449   }
 450
 451   if (PathNameLength > LONGNAME_MAX_LENGTH * sizeof(WCHAR))
 452   {
 453     return  STATUS_OBJECT_NAME_INVALID;
 454   }
 455   PathNameBuffer = ExAllocatePool(NonPagedPool, PathNameLength + sizeof(WCHAR));
 456   if (!PathNameBuffer)
 457   {
 458     return STATUS_INSUFFICIENT_RESOURCES;
 459   }
 460   NameU.Buffer = PathNameBuffer;
 461   NameU.Length = 0;
 462   NameU.MaximumLength = PathNameLength;
 463
 464   RtlCopyUnicodeString(&NameU, &directoryFCB->PathNameU);
 465   if (!vfatFCBIsRoot (directoryFCB))
 466   {
 467     RtlAppendUnicodeToString(&NameU, L"\\");
 468   }
 469   hash = vfatNameHash(0, &NameU);
 470   if (DirContext->LongNameU.Length > 0)
 471   {
 472     RtlAppendUnicodeStringToString(&NameU, &DirContext->LongNameU);
 473   }
 474   else
 475   {
 476     RtlAppendUnicodeStringToString(&NameU, &DirContext->ShortNameU);
 477   }
 478   NameU.Buffer[NameU.Length / sizeof(WCHAR)] = 0;
 479
 480   rcFCB = vfatNewFCB (vcb, &NameU);
 481   RtlCopyMemory (&rcFCB->entry, &DirContext->DirEntry, sizeof (DIR_ENTRY));
 482   RtlCopyUnicodeString(&rcFCB->ShortNameU, &DirContext->ShortNameU);
 483   if (vcb->Flags & VCB_IS_FATX)
 484   {
 485     rcFCB->ShortHash.Hash = rcFCB->Hash.Hash;
 486   }
 487   else
 488   {
 489     rcFCB->ShortHash.Hash = vfatNameHash(hash, &rcFCB->ShortNameU);
 490   }
 491
 492   if (vfatFCBIsDirectory(rcFCB))
 493   {
 494     ULONG FirstCluster, CurrentCluster;
 495     NTSTATUS Status;
 496     Size = 0;
 497     FirstCluster = vfatDirEntryGetFirstCluster (vcb, &rcFCB->entry);
 498     if (FirstCluster == 1)
 499     {
 500       Size = vcb->FatInfo.rootDirectorySectors * vcb->FatInfo.BytesPerSector;
 501     }
 502     else if (FirstCluster != 0)
 503     {
 504       CurrentCluster = FirstCluster;
 505       while (CurrentCluster != 0xffffffff)
 506       {
 507          Size += vcb->FatInfo.BytesPerCluster;
 508          Status = NextCluster (vcb, FirstCluster, &CurrentCluster, FALSE);
 509       }
 510     }
 511   }
 512   else if (rcFCB->Flags & FCB_IS_FATX_ENTRY)
 513   {
 514     Size = rcFCB->entry.FatX.FileSize;
 515   }
 516   else
 517   {
 518     Size = rcFCB->entry.Fat.FileSize;
 519   }
 520   rcFCB->dirIndex = DirContext->DirIndex;
 521   rcFCB->startIndex = DirContext->StartIndex;
 522   if ((rcFCB->Flags & FCB_IS_FATX_ENTRY) && !vfatFCBIsRoot (directoryFCB))
 523     {
 524       ASSERT(DirContext->DirIndex >= 2 && DirContext->StartIndex >= 2);
 525       rcFCB->dirIndex = DirContext->DirIndex-2;
 526       rcFCB->startIndex = DirContext->StartIndex-2;
 527     }
 528   rcFCB->RFCB.FileSize.QuadPart = Size;
 529   rcFCB->RFCB.ValidDataLength.QuadPart = Size;
 530   rcFCB->RFCB.AllocationSize.QuadPart = ROUND_UP(Size, vcb->FatInfo.BytesPerCluster);
 531   rcFCB->RefCount++;
 532   if (vfatFCBIsDirectory(rcFCB))
 533     {
 534       vfatFCBInitializeCacheFromVolume(vcb, rcFCB);
 535     }
 536   rcFCB->parentFcb = directoryFCB;
 537   vfatAddFCBToTable (vcb, rcFCB);
 538   *fileFCB = rcFCB;
 539
 540   ExFreePool(PathNameBuffer);
 541   return  STATUS_SUCCESS;
 542 }
 543
 544 NTSTATUS
 545 vfatAttachFCBToFileObject (PDEVICE_EXTENSION  vcb,
 546                            PVFATFCB  fcb,
 547                            PFILE_OBJECT  fileObject)
 548 {
 549   PVFATCCB  newCCB;
 550
 551   newCCB = ExAllocateFromNPagedLookasideList(&VfatGlobalData->CcbLookasideList);
 552   if (newCCB == NULL)
 553   {
 554     CHECKPOINT;
 555     return  STATUS_INSUFFICIENT_RESOURCES;
 556   }
 557   RtlZeroMemory (newCCB, sizeof (VFATCCB));
 558
 559   fileObject->SectionObjectPointer = &fcb->SectionObjectPointers;
 560   fileObject->FsContext = fcb;
 561   fileObject->FsContext2 = newCCB;
 562   DPRINT ("file open: fcb:%x PathName:%wZ\n", fcb, &fcb->PathNameU);
 563
 564   return  STATUS_SUCCESS;
 565 }
 566
 567 NTSTATUS
 568 vfatDirFindFile (PDEVICE_EXTENSION  pDeviceExt,
 569                  PVFATFCB  pDirectoryFCB,
 570                  PUNICODE_STRING FileToFindU,
 571                  PVFATFCB * pFoundFCB)
 572 {
 573   NTSTATUS  status;
 574   PVOID Context = NULL;
 575   PVOID Page = NULL;
 576   BOOLEAN First = TRUE;
 577   VFAT_DIRENTRY_CONTEXT DirContext;
 578   /* This buffer must have a size of 260 characters, because
 579      vfatMakeFCBFromDirEntry can copy 20 name entries with 13 characters. */
 580   WCHAR LongNameBuffer[260];
 581   WCHAR ShortNameBuffer[13];
 582   BOOLEAN FoundLong = FALSE;
 583   BOOLEAN FoundShort = FALSE;
 584
 585   ASSERT(pDeviceExt);
 586   ASSERT(pDirectoryFCB);
 587   ASSERT(FileToFindU);
 588
 589   DPRINT ("vfatDirFindFile(VCB:%08x, dirFCB:%08x, File:%wZ)\n",
 590           pDeviceExt,
 591           pDirectoryFCB,
 592           FileToFindU);
 593   DPRINT ("Dir Path:%wZ\n", &pDirectoryFCB->PathNameU);
 594
 595   DirContext.DirIndex = 0;
 596   DirContext.LongNameU.Buffer = LongNameBuffer;
 597   DirContext.LongNameU.Length = 0;
 598   DirContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
 599   DirContext.ShortNameU.Buffer = ShortNameBuffer;
 600   DirContext.ShortNameU.Length = 0;
 601   DirContext.ShortNameU.MaximumLength = sizeof(ShortNameBuffer);
 602
 603   while (TRUE)
 604     {
 605       status = pDeviceExt->GetNextDirEntry(&Context,
 606                                    &Page,
 607                                    pDirectoryFCB,
 608                                    &DirContext,
 609                                    First);
 610       First = FALSE;
 611       if (status == STATUS_NO_MORE_ENTRIES)
 612         {
 613           return STATUS_OBJECT_NAME_NOT_FOUND;
 614         }
 615       if (!NT_SUCCESS(status))
 616         {
 617           return status;
 618         }
 619
 620       DPRINT ("  Index:%d  longName:%wZ\n",
 621               DirContext.DirIndex,
 622               &DirContext.LongNameU);
 623       DirContext.LongNameU.Buffer[DirContext.LongNameU.Length / sizeof(WCHAR)] = 0;
 624       DirContext.ShortNameU.Buffer[DirContext.ShortNameU.Length / sizeof(WCHAR)] = 0;
 625       if (!ENTRY_VOLUME(pDeviceExt, &DirContext.DirEntry))
 626         {
 627           FoundLong = RtlEqualUnicodeString(FileToFindU, &DirContext.LongNameU, TRUE);
 628           if (FoundLong == FALSE)
 629             {
 630               FoundShort = RtlEqualUnicodeString(FileToFindU, &DirContext.ShortNameU, TRUE);
 631             }
 632           if (FoundLong || FoundShort)
 633             {
 634               status = vfatMakeFCBFromDirEntry (pDeviceExt,
 635                                                 pDirectoryFCB,
 636                                                 &DirContext,
 637                                                 pFoundFCB);
 638               CcUnpinData(Context);
 639               return  status;
 640             }
 641         }
 642       DirContext.DirIndex++;
 643   }
 644
 645   return  STATUS_OBJECT_NAME_NOT_FOUND;
 646 }
 647
 648 NTSTATUS
 649 vfatGetFCBForFile (PDEVICE_EXTENSION  pVCB,
 650                    PVFATFCB  *pParentFCB,
 651                    PVFATFCB  *pFCB,
 652                    PUNICODE_STRING pFileNameU)
 653 {
 654   NTSTATUS  status;
 655   PVFATFCB  FCB = NULL;
 656   PVFATFCB  parentFCB;
 657   UNICODE_STRING NameU;
 658   UNICODE_STRING RootNameU = RTL_CONSTANT_STRING(L"\\");
 659   PWCHAR curr, prev, last;
 660   ULONG Length;
 661
 662   DPRINT ("vfatGetFCBForFile (%x,%x,%x,%wZ)\n",
 663           pVCB,
 664           pParentFCB,
 665           pFCB,
 666           pFileNameU);
 667
 668   parentFCB = *pParentFCB;
 669
 670   if (parentFCB == NULL)
 671   {
 672      //  Trivial case, open of the root directory on volume
 673      if (RtlEqualUnicodeString(pFileNameU, &RootNameU, FALSE))
 674      {
 675         DPRINT ("returning root FCB\n");
 676
 677         FCB = vfatOpenRootFCB (pVCB);
 678         *pFCB = FCB;
 679         *pParentFCB = NULL;
 680
 681         return  (FCB != NULL) ? STATUS_SUCCESS : STATUS_OBJECT_PATH_NOT_FOUND;
 682      }
 683
 684      /* Check for an existing FCB */
 685      FCB = vfatGrabFCBFromTable (pVCB, pFileNameU);
 686      if (FCB)
 687      {
 688         *pFCB = FCB;
 689         *pParentFCB = FCB->parentFcb;
 690         (*pParentFCB)->RefCount++;
 691         return STATUS_SUCCESS;
 692      }
 693
 694      last = curr = pFileNameU->Buffer + pFileNameU->Length / sizeof(WCHAR) - 1;
 695      while (*curr != L'\\' && curr > pFileNameU->Buffer)
 696      {
 697         curr--;
 698      }
 699
 700      if (curr > pFileNameU->Buffer)
 701      {
 702         NameU.Buffer = pFileNameU->Buffer;
 703         NameU.MaximumLength = NameU.Length = (curr - pFileNameU->Buffer) * sizeof(WCHAR);
 704         FCB = vfatGrabFCBFromTable(pVCB, &NameU);
 705         if (FCB)
 706         {
 707            Length = (curr - pFileNameU->Buffer) * sizeof(WCHAR);
 708            if (Length != FCB->PathNameU.Length)
 709            {
 710               if (pFileNameU->Length + FCB->PathNameU.Length - Length > pFileNameU->MaximumLength)
 711               {
 712                  vfatReleaseFCB (pVCB, FCB);
 713                  return STATUS_OBJECT_NAME_INVALID;
 714               }
 715               RtlMoveMemory(pFileNameU->Buffer + FCB->PathNameU.Length / sizeof(WCHAR),
 716                       curr, pFileNameU->Length - Length);
 717               pFileNameU->Length += (USHORT)(FCB->PathNameU.Length - Length);
 718               curr = pFileNameU->Buffer + FCB->PathNameU.Length / sizeof(WCHAR);
 719               last = pFileNameU->Buffer + pFileNameU->Length / sizeof(WCHAR) - 1;
 720           }
 721           RtlCopyMemory(pFileNameU->Buffer, FCB->PathNameU.Buffer, FCB->PathNameU.Length);
 722         }
 723      }
 724      else
 725      {
 726        FCB = NULL;
 727      }
 728
 729      if (FCB == NULL)
 730      {
 731        FCB = vfatOpenRootFCB(pVCB);
 732        curr = pFileNameU->Buffer;
 733      }
 734
 735      parentFCB = NULL;
 736      prev = curr;
 737   }
 738   else
 739   {
 740      FCB = parentFCB;
 741      parentFCB = NULL;
 742      prev = curr = pFileNameU->Buffer - 1;
 743      last = pFileNameU->Buffer + pFileNameU->Length / sizeof(WCHAR) - 1;
 744   }
 745
 746   while (curr <= last)
 747     {
 748       if (parentFCB)
 749         {
 750           vfatReleaseFCB (pVCB, parentFCB);
 751           parentFCB = 0;
 752         }
 753       //  fail if element in FCB is not a directory
 754       if (!vfatFCBIsDirectory (FCB))
 755         {
 756           DPRINT ("Element in requested path is not a directory\n");
 757
 758           vfatReleaseFCB (pVCB, FCB);
 759           FCB = NULL;
 760           *pParentFCB = NULL;
 761           *pFCB = NULL;
 762
 763           return  STATUS_OBJECT_PATH_NOT_FOUND;
 764         }
 765       parentFCB = FCB;
 766       if (prev < curr)
 767         {
 768           Length = (curr - prev) * sizeof(WCHAR);
 769           if (Length != parentFCB->LongNameU.Length)
 770             {
 771               if (pFileNameU->Length + parentFCB->LongNameU.Length - Length > pFileNameU->MaximumLength)
 772                 {
 773                   vfatReleaseFCB (pVCB, parentFCB);
 774                   return STATUS_OBJECT_NAME_INVALID;
 775                 }
 776               RtlMoveMemory(prev + parentFCB->LongNameU.Length / sizeof(WCHAR), curr,
 777                       pFileNameU->Length - (curr - pFileNameU->Buffer) * sizeof(WCHAR));
 778               pFileNameU->Length += (USHORT)(parentFCB->LongNameU.Length - Length);
 779               curr = prev + parentFCB->LongNameU.Length / sizeof(WCHAR);
 780               last = pFileNameU->Buffer + pFileNameU->Length / sizeof(WCHAR) - 1;
 781             }
 782           RtlCopyMemory(prev, parentFCB->LongNameU.Buffer, parentFCB->LongNameU.Length);
 783         }
 784       curr++;
 785       prev = curr;
 786       while (*curr != L'\\' && curr <= last)
 787         {
 788           curr++;
 789         }
 790       NameU.Buffer = pFileNameU->Buffer;
 791       NameU.Length = (curr - NameU.Buffer) * sizeof(WCHAR);
 792       NameU.MaximumLength = pFileNameU->MaximumLength;
 793       DPRINT("%wZ\n", &NameU);
 794       FCB = vfatGrabFCBFromTable(pVCB, &NameU);
 795       if (FCB == NULL)
 796         {
 797           NameU.Buffer = prev;
 798           NameU.MaximumLength = NameU.Length = (curr - prev) * sizeof(WCHAR);
 799           status = vfatDirFindFile(pVCB, parentFCB, &NameU, &FCB);
 800           if (status == STATUS_OBJECT_NAME_NOT_FOUND)
 801             {
 802               *pFCB = NULL;
 803               if (curr > last)
 804                 {
 805                   *pParentFCB = parentFCB;
 806                   return  STATUS_OBJECT_NAME_NOT_FOUND;
 807                 }
 808               else
 809                 {
 810                   vfatReleaseFCB (pVCB, parentFCB);
 811                   *pParentFCB = NULL;
 812                   return  STATUS_OBJECT_PATH_NOT_FOUND;
 813                 }
 814             }
 815           else if (!NT_SUCCESS (status))
 816             {
 817               vfatReleaseFCB (pVCB, parentFCB);
 818               *pParentFCB = NULL;
 819               *pFCB = NULL;
 820
 821               return  status;
 822             }
 823         }
 824     }
 825
 826   *pParentFCB = parentFCB;
 827   *pFCB = FCB;
 828
 829   return  STATUS_SUCCESS;
 830 }
 831