drivers/filesystems/cdfs_new/dirsup.c

   1 /*++
   2
   3 Copyright (c) 1989-2000 Microsoft Corporation
   4
   5 Module Name:
   6
   7     DirSup.c
   8
   9 Abstract:
  10
  11     This module implements the dirent support routines for Cdfs.
  12
  13     Directories on a CD consist of a number of contiguous sectors on
  14     the disk.  File descriptors consist of one or more directory entries
  15     (dirents) within a directory.  Files may contain version numbers.  If
  16     present all like-named files will be ordered contiguously in the
  17     directory by decreasing version numbers.  We will only return the
  18     first of these on a directory query unless the user explicitly
  19     asks for version numbers.  Finally dirents will not span sector
  20     boundaries.  Unused bytes at the end of a sector will be zero
  21     filled.
  22
  23     Directory sector:                                                   Offset
  24                                                                         2048
  25         +---------------------------------------------------------------+
  26         |            |          |          |           |          |     |
  27         | foo;4      | foo;4    | foo;3    |  hat      |  zebra   | Zero|
  28         |            |          |          |           |          | Fill|
  29         |            |  final   |  single  |           |          |     |
  30         |            |  extent  |   extent |           |          |     |
  31         +---------------------------------------------------------------+
  32
  33     Dirent operations:
  34
  35         - Position scan at known offset in directory.  Dirent at this
  36             offset must exist and is valid.  Used when scanning a directory
  37             from the beginning when the self entry is known to be valid.
  38             Used when positioning at the first dirent for an open
  39             file to scan the allocation information.  Used when resuming
  40             a directory enumeration from a valid directory entry.
  41
  42         - Position scan at known offset in directory.  Dirent is known to
  43             start at this position but must be checked for validity.
  44             Used to read the self-directory entry.
  45
  46         - Move to the next dirent within a directory.
  47
  48         - Given a known starting dirent, collect all the dirents for
  49             that file.  Scan will finish positioned at the last dirent
  50             for the file.  We will accumulate the extent lengths to
  51             find the size of the file.
  52
  53         - Given a known starting dirent, position the scan for the first
  54             dirent of the following file.  Used when not interested in
  55             all of the details for the current file and are looking for
  56             the next file.
  57
  58         - Update a common dirent structure with the details of the on-disk
  59             structure.  This is used to smooth out the differences
  60
  61         - Build the filename (name and version strings) out of the stream
  62             of bytes in the file name on disk.  For Joliet disks we will have
  63             to convert to little endian.
  64
  65
  66 --*/
  67
  68 #include "CdProcs.h"
  69
  70 //
  71 //  The Bug check file id for this module
  72 //
  73
  74 #define BugCheckFileId                   (CDFS_BUG_CHECK_DIRSUP)
  75
  76 //
  77 //  Local macros
  78 //
  79
  80 //
  81 //  PRAW_DIRENT
  82 //  CdRawDirent (
  83 //      _In_ PIRP_CONTEXT IrpContext,
  84 //      _In_ PDIR_ENUM_CONTEXT DirContext
  85 //      );
  86 //
  87
  88 #define CdRawDirent(IC,DC)                                      \
  89     Add2Ptr( (DC)->Sector, (DC)->SectorOffset, PRAW_DIRENT )
  90
  91 //
  92 //  Local support routines
  93 //
  94
  95 ULONG
  96 CdCheckRawDirentBounds (
  97     _In_ PIRP_CONTEXT IrpContext,
  98     _In_ PDIRENT_ENUM_CONTEXT DirContext
  99     );
 100
 101 XA_EXTENT_TYPE
 102 CdCheckForXAExtent (
 103     _In_ PIRP_CONTEXT IrpContext,
 104     _In_ PRAW_DIRENT RawDirent,
 105     _Inout_ PDIRENT Dirent
 106     );
 107
 108 #ifdef ALLOC_PRAGMA
 109 #pragma alloc_text(PAGE, CdCheckForXAExtent)
 110 #pragma alloc_text(PAGE, CdCheckRawDirentBounds)
 111 #pragma alloc_text(PAGE, CdCleanupFileContext)
 112 #pragma alloc_text(PAGE, CdFindFile)
 113 #pragma alloc_text(PAGE, CdFindDirectory)
 114 #pragma alloc_text(PAGE, CdFindFileByShortName)
 115 #pragma alloc_text(PAGE, CdLookupDirent)
 116 #pragma alloc_text(PAGE, CdLookupLastFileDirent)
 117 #pragma alloc_text(PAGE, CdLookupNextDirent)
 118 #pragma alloc_text(PAGE, CdLookupNextInitialFileDirent)
 119 #pragma alloc_text(PAGE, CdUpdateDirentFromRawDirent)
 120 #pragma alloc_text(PAGE, CdUpdateDirentName)
 121 #endif
 122
 123 \f
 124 VOID
 125 CdLookupDirent (
 126     _In_ PIRP_CONTEXT IrpContext,
 127     _In_ PFCB Fcb,
 128     _In_ ULONG DirentOffset,
 129     _Out_ PDIRENT_ENUM_CONTEXT DirContext
 130     )
 131
 132 /*++
 133
 134 Routine Description:
 135
 136     This routine is called to initiate a walk through a directory.  We will
 137     position ourselves in the directory at offset DirentOffset.  We know that
 138     a dirent begins at this boundary but may have to verify the dirent bounds.
 139     We will call this routine when looking up the first entry of a known
 140     file or verifying the self entry of a directory.
 141
 142 Arguments:
 143
 144     Fcb - Fcb for the directory being traversed.
 145
 146     DirentOffset - This is our target point in the directory.  We will map the
 147         page containing this entry and possibly verify the dirent bounds at
 148         this location.
 149
 150     DirContext - This is the dirent context for this scan.  We update it with
 151         the location of the dirent we found.  This structure has been initialized
 152         outside of this call.
 153
 154 Return Value:
 155
 156     None.
 157
 158 --*/
 159
 160 {
 161     LONGLONG BaseOffset;
 162
 163     PAGED_CODE();
 164
 165     //
 166     //  Initialize the offset of the first dirent we want to map.
 167     //
 168
 169     DirContext->BaseOffset = SectorTruncate( DirentOffset );
 170     BaseOffset = DirContext->BaseOffset;
 171
 172     DirContext->DataLength = SECTOR_SIZE;
 173
 174     DirContext->SectorOffset = SectorOffset( DirentOffset );
 175
 176     //
 177     //  Truncate the data length if we are at the end of the file.
 178     //
 179
 180     if (DirContext->DataLength > (Fcb->FileSize.QuadPart - BaseOffset)) {
 181
 182         DirContext->DataLength = (ULONG) (Fcb->FileSize.QuadPart - BaseOffset);
 183     }
 184
 185     //
 186     //  Now map the data at this offset.
 187     //
 188
 189     CcMapData( Fcb->FileObject,
 190                (PLARGE_INTEGER) &BaseOffset,
 191                DirContext->DataLength,
 192                TRUE,
 193                &DirContext->Bcb,
 194                &DirContext->Sector );
 195
 196     //
 197     //  Verify the dirent bounds.
 198     //
 199
 200     DirContext->NextDirentOffset = CdCheckRawDirentBounds( IrpContext,
 201                                                            DirContext );
 202
 203     return;
 204 }
 205
 206 \f
 207 BOOLEAN
 208 CdLookupNextDirent (
 209     _In_ PIRP_CONTEXT IrpContext,
 210     _In_ PFCB Fcb,
 211     _In_ PDIRENT_ENUM_CONTEXT CurrentDirContext,
 212     _Inout_ PDIRENT_ENUM_CONTEXT NextDirContext
 213     )
 214
 215 /*++
 216
 217 Routine Description:
 218
 219     This routine is called to find the next dirent in the directory.  The
 220     current position is given and we look for the next.  We leave the context
 221     for the starting position untouched and update the context for the
 222     dirent we found.  The target context may already be initialized so we
 223     may already have the sector in memory.
 224
 225     This routine will position the enumeration context for the next dirent and
 226     verify the dirent bounds.
 227
 228     NOTE - This routine can be called with CurrentDirContext and NextDirContext
 229         pointing to the same enumeration context.
 230
 231 Arguments:
 232
 233     Fcb - Fcb for the directory being traversed.
 234
 235     CurrentDirContext - This is the dirent context for this scan.  We update
 236         it with the location of the dirent we found.  This is currently
 237         pointing to a dirent location.  The dirent bounds at this location
 238         have already been verified.
 239
 240     NextDirContext - This is the dirent context to update with the dirent we
 241         find.  This may already point to a dirent so we need to check if
 242         we are in the same sector and unmap any buffer as necessary.
 243
 244         This dirent is left in an indeterminant state if we don't find a dirent.
 245
 246 Return Value:
 247
 248     BOOLEAN - TRUE if we find a location for the next dirent, FALSE otherwise.
 249         This routine can cause a raise if the directory is corrupt.
 250
 251 --*/
 252
 253 {
 254     LONGLONG CurrentBaseOffset = CurrentDirContext->BaseOffset;
 255     ULONG TempUlong;
 256
 257     BOOLEAN FoundDirent = FALSE;
 258
 259     PAGED_CODE();
 260
 261     //
 262     //  Check if a different sector is mapped.  If so then move our target
 263     //  enumeration context to the same sector.
 264     //
 265
 266     if ((CurrentDirContext->BaseOffset != NextDirContext->BaseOffset) ||
 267         (NextDirContext->Bcb == NULL)) {
 268
 269         //
 270         //  Unpin the current target Bcb and map the next sector.
 271         //
 272
 273         CdUnpinData( IrpContext, &NextDirContext->Bcb );
 274
 275         CcMapData( Fcb->FileObject,
 276                    (PLARGE_INTEGER) &CurrentBaseOffset,
 277                    CurrentDirContext->DataLength,
 278                    TRUE,
 279                    &NextDirContext->Bcb,
 280                    &NextDirContext->Sector );
 281
 282         //
 283         //  Copy the data length and sector offset.
 284         //
 285
 286         NextDirContext->DataLength = CurrentDirContext->DataLength;
 287         NextDirContext->BaseOffset = CurrentDirContext->BaseOffset;
 288     }
 289
 290     //
 291     //  Now move to the same offset in the sector.
 292     //
 293
 294     NextDirContext->SectorOffset = CurrentDirContext->SectorOffset;
 295
 296     //
 297     //  If the value is zero then unmap the current sector and set up
 298     //  the base offset to the beginning of the next sector.
 299     //
 300
 301     if (CurrentDirContext->NextDirentOffset == 0) {
 302
 303         CurrentBaseOffset = NextDirContext->BaseOffset + NextDirContext->DataLength;
 304
 305         //
 306         //  Unmap the current sector.  We test the value of the Bcb in the
 307         //  loop below to see if we need to read in another sector.
 308         //
 309
 310         CdUnpinData( IrpContext, &NextDirContext->Bcb );
 311
 312     //
 313     //  There is another possible dirent in the current sector.  Update the
 314     //  enumeration context to reflect this.
 315     //
 316
 317     } else {
 318
 319         NextDirContext->SectorOffset += CurrentDirContext->NextDirentOffset;
 320     }
 321
 322     //
 323     //  Now loop until we find the next possible dirent or walk off the directory.
 324     //
 325
 326     while (TRUE) {
 327
 328         //
 329         //  If we don't currently have a sector mapped then map the
 330         //  directory at the current offset.
 331         //
 332
 333         if (NextDirContext->Bcb == NULL) {
 334
 335             TempUlong = SECTOR_SIZE;
 336
 337             if (TempUlong > (ULONG) (Fcb->FileSize.QuadPart - CurrentBaseOffset)) {
 338
 339                 TempUlong = (ULONG) (Fcb->FileSize.QuadPart - CurrentBaseOffset);
 340
 341                 //
 342                 //  If the length is zero then there is no dirent.
 343                 //
 344
 345                 if (TempUlong == 0) {
 346
 347                     break;
 348                 }
 349             }
 350
 351             CcMapData( Fcb->FileObject,
 352                        (PLARGE_INTEGER) &CurrentBaseOffset,
 353                        TempUlong,
 354                        TRUE,
 355                        &NextDirContext->Bcb,
 356                        &NextDirContext->Sector );
 357
 358             NextDirContext->BaseOffset = (ULONG) CurrentBaseOffset;
 359             NextDirContext->SectorOffset = 0;
 360             NextDirContext->DataLength = TempUlong;
 361         }
 362
 363         //
 364         //  The CDFS spec allows for sectors in a directory to contain all zeroes.
 365         //  In this case we need to move to the next sector.  So look at the
 366         //  current potential dirent for a zero length.  Move to the next
 367         //  dirent if length is zero.
 368         //
 369
 370         if (*((PCHAR) CdRawDirent( IrpContext, NextDirContext )) != 0) {
 371
 372             FoundDirent = TRUE;
 373             break;
 374         }
 375
 376         CurrentBaseOffset = NextDirContext->BaseOffset + NextDirContext->DataLength;
 377         CdUnpinData( IrpContext, &NextDirContext->Bcb );
 378     }
 379
 380     //
 381     //  Check the dirent bounds if we found a dirent.
 382     //
 383
 384     if (FoundDirent) {
 385
 386         NextDirContext->NextDirentOffset = CdCheckRawDirentBounds( IrpContext,
 387                                                                    NextDirContext );
 388     }
 389
 390     return FoundDirent;
 391 }
 392
 393
 394 _At_(Dirent->CdTime, _Post_notnull_)\f
 395 VOID
 396 CdUpdateDirentFromRawDirent (
 397     _In_ PIRP_CONTEXT IrpContext,
 398     _In_ PFCB Fcb,
 399     _In_ PDIRENT_ENUM_CONTEXT DirContext,
 400     _Inout_ PDIRENT Dirent
 401     )
 402
 403 /*++
 404
 405 Routine Description:
 406
 407     This routine is called to safely copy the data from the dirent on disk
 408     to the in-memory dirent.  The fields on disk are unaligned so we
 409     need to safely copy them to our structure.
 410
 411 Arguments:
 412
 413     Fcb - Fcb for the directory being scanned.
 414
 415     DirContext - Enumeration context for the raw disk dirent.
 416
 417     Dirent - In-memory dirent to update.
 418
 419 Return Value:
 420
 421     None.
 422
 423 --*/
 424
 425 {
 426     PRAW_DIRENT RawDirent = CdRawDirent( IrpContext, DirContext );
 427
 428     PAGED_CODE();
 429
 430     UNREFERENCED_PARAMETER( Fcb );
 431
 432     //
 433     //  Clear all of the current state flags except the flag indicating that
 434     //  we allocated a name string.
 435     //
 436
 437     ClearFlag( Dirent->Flags, DIRENT_FLAG_NOT_PERSISTENT );
 438
 439     //
 440     //  The dirent offset is the sum of the start of the sector and the
 441     //  sector offset.
 442     //
 443
 444     Dirent->DirentOffset = DirContext->BaseOffset + DirContext->SectorOffset;
 445
 446     //
 447     //  Copy the dirent length from the raw dirent.
 448     //
 449
 450     Dirent->DirentLength = RawDirent->DirLen;
 451
 452     //
 453     //  The starting offset on disk is computed by finding the starting
 454     //  logical block and stepping over the Xar block.
 455     //
 456
 457     CopyUchar4( &Dirent->StartingOffset, RawDirent->FileLoc );
 458
 459     Dirent->StartingOffset += RawDirent->XarLen;
 460
 461     //
 462     //  Do a safe copy to get the data length.
 463     //
 464
 465     CopyUchar4( &Dirent->DataLength, RawDirent->DataLen );
 466
 467     //
 468     //  Save a pointer to the time stamps.
 469     //
 470
 471     Dirent->CdTime = (PCHAR)RawDirent->RecordTime;
 472
 473     //
 474     //  Copy the dirent flags.
 475     //
 476
 477     Dirent->DirentFlags = CdRawDirentFlags( IrpContext, RawDirent );
 478
 479     //
 480     //  For both the file unit and interleave skip we want to take the
 481     //  logical block count.
 482     //
 483
 484     Dirent->FileUnitSize =
 485     Dirent->InterleaveGapSize = 0;
 486
 487     if (RawDirent->IntLeaveSize != 0) {
 488
 489         Dirent->FileUnitSize = RawDirent->IntLeaveSize;
 490         Dirent->InterleaveGapSize = RawDirent->IntLeaveSkip;
 491     }
 492
 493     //
 494     //  Get the name length and remember a pointer to the start of the
 495     //  name string.  We don't do any processing on the name at this
 496     //  point.
 497     //
 498     //  Check that the name length is non-zero.
 499     //
 500
 501     if (RawDirent->FileIdLen == 0) {
 502
 503         CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
 504     }
 505
 506     Dirent->FileNameLen = RawDirent->FileIdLen;
 507     Dirent->FileName = (PCHAR)RawDirent->FileId;
 508
 509     //
 510     //  If there are any remaining bytes at the end of the dirent then
 511     //  there may be a system use area.  We protect ourselves from
 512     //  disks which don't pad the dirent entries correctly by using
 513     //  a fudge factor of one.  All system use areas must have a length
 514     //  greater than one.  Don't bother with the system use area
 515     //  if this is a directory.
 516     //
 517
 518     Dirent->XAAttributes = 0;
 519     Dirent->XAFileNumber = 0;
 520     Dirent->ExtentType = Form1Data;
 521     Dirent->SystemUseOffset = 0;
 522
 523     if (!FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY ) &&
 524         (Dirent->DirentLength > ((FIELD_OFFSET( RAW_DIRENT, FileId ) + Dirent->FileNameLen) + 1))) {
 525
 526         Dirent->SystemUseOffset = WordAlign( FIELD_OFFSET( RAW_DIRENT, FileId ) + Dirent->FileNameLen );
 527     }
 528
 529     return;
 530 }
 531
 532 \f
 533 VOID
 534 CdUpdateDirentName (
 535     _In_ PIRP_CONTEXT IrpContext,
 536     _Inout_ PDIRENT Dirent,
 537     _In_ ULONG IgnoreCase
 538     )
 539
 540 /*++
 541
 542 Routine Description:
 543
 544     This routine is called to update the name in the dirent with the name
 545     from the disk.  We will look for the special case of the self and
 546     parent entries and also construct the Unicode name for the Joliet disk
 547     in order to work around the BigEndian on-disk structure.
 548
 549 Arguments:
 550
 551     Dirent - Pointer to the in-memory dirent structure.
 552
 553     IgnoreCase - TRUE if we should build the upcased version.  Otherwise we
 554         use the exact case name.
 555
 556 Return Value:
 557
 558     None.
 559
 560 --*/
 561
 562 {
 563     UCHAR DirectoryValue;
 564     ULONG Length;
 565
 566     NTSTATUS Status;
 567
 568     PAGED_CODE();
 569
 570     //
 571     //  Check if this is a self or parent entry.  There is no version number
 572     //  in these cases.  We use a fixed string for these.
 573     //
 574     //      Self-Entry - Length is 1, value is 0.
 575     //      Parent-Entry - Length is 1, value is 1.
 576     //
 577
 578     if ((Dirent->FileNameLen == 1) &&
 579         FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY )) {
 580
 581         DirectoryValue = *((PCHAR) Dirent->FileName);
 582
 583         if ((DirectoryValue == 0) || (DirectoryValue == 1)) {
 584
 585             //
 586             //  We should not have allocated a name by the time we see these cases.
 587             //  If we have, this means that the image is in violation of ISO 9660 7.6.2,
 588             //  which states that the ./.. entries must be the first two in the directory.
 589             //
 590
 591             if (FlagOn( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER )) {
 592
 593                 CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
 594             }
 595
 596             //
 597             //  Now use one of the hard coded directory names.
 598             //
 599
 600             Dirent->CdFileName.FileName = CdUnicodeDirectoryNames[DirectoryValue];
 601
 602             //
 603             //  Show that there is no version number.
 604             //
 605
 606             Dirent->CdFileName.VersionString.Length = 0;
 607
 608             //
 609             //  The case name is the same as the exact name.
 610             //
 611
 612             Dirent->CdCaseFileName = Dirent->CdFileName;
 613
 614             //
 615             //  Mark this as a constant value entry.
 616             //
 617
 618             SetFlag( Dirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY );
 619
 620             //
 621             //  Return now.
 622             //
 623
 624             return;
 625         }
 626     }
 627
 628     //
 629     //  Mark this as a non-constant value entry.
 630     //
 631
 632     ClearFlag( Dirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY );
 633
 634     //
 635     //  Compute how large a buffer we will need.  If this is an ignore
 636     //  case operation then we will want a double size buffer.  If the disk is not
 637     //  a Joliet disk then we might need two bytes for each byte in the name.
 638     //
 639
 640     Length = Dirent->FileNameLen;
 641
 642     if (IgnoreCase) {
 643
 644         Length *= 2;
 645     }
 646
 647     if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 648
 649         Length *= sizeof( WCHAR );
 650     }
 651
 652     //
 653     //  Now decide if we need to allocate a new buffer.  We will if
 654     //  this name won't fit in the embedded name buffer and it is
 655     //  larger than the current allocated buffer.  We always use the
 656     //  allocated buffer if present.
 657     //
 658     //  If we haven't allocated a buffer then use the embedded buffer if the data
 659     //  will fit.  This is the typical case.
 660     //
 661
 662     if (!FlagOn( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER ) &&
 663         (Length <= sizeof( Dirent->NameBuffer ))) {
 664
 665         Dirent->CdFileName.FileName.MaximumLength = sizeof( Dirent->NameBuffer );
 666         Dirent->CdFileName.FileName.Buffer = Dirent->NameBuffer;
 667
 668     } else {
 669
 670         //
 671         //  We need to use an allocated buffer.  Check if the current buffer
 672         //  is large enough.
 673         //
 674
 675         if (Length > Dirent->CdFileName.FileName.MaximumLength) {
 676
 677             //
 678             //  Free any allocated buffer.
 679             //
 680
 681             if (FlagOn( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER )) {
 682
 683                 CdFreePool( &Dirent->CdFileName.FileName.Buffer );
 684                 ClearFlag( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER );
 685             }
 686
 687             Dirent->CdFileName.FileName.Buffer = FsRtlAllocatePoolWithTag( CdPagedPool,
 688                                                                             Length,
 689                                                                             TAG_DIRENT_NAME );
 690
 691             SetFlag( Dirent->Flags, DIRENT_FLAG_ALLOC_BUFFER );
 692
 693             Dirent->CdFileName.FileName.MaximumLength = (USHORT) Length;
 694         }
 695     }
 696
 697     //
 698     //  We now have a buffer for the name.  We need to either convert the on-disk bigendian
 699     //  to little endian or covert the name to Unicode.
 700     //
 701
 702     if (!FlagOn( IrpContext->Vcb->VcbState, VCB_STATE_JOLIET )) {
 703
 704         Status = RtlOemToUnicodeN( Dirent->CdFileName.FileName.Buffer,
 705                                    Dirent->CdFileName.FileName.MaximumLength,
 706                                    &Length,
 707                                    Dirent->FileName,
 708                                    Dirent->FileNameLen );
 709
 710         __analysis_assert( Status == STATUS_SUCCESS );
 711         NT_ASSERT( Status == STATUS_SUCCESS );
 712         Dirent->CdFileName.FileName.Length = (USHORT) Length;
 713
 714     } else {
 715
 716         //
 717         //  Convert this string to little endian.
 718         //
 719
 720         CdConvertBigToLittleEndian( IrpContext,
 721                                     Dirent->FileName,
 722                                     Dirent->FileNameLen,
 723                                     (PCHAR) Dirent->CdFileName.FileName.Buffer );
 724
 725         Dirent->CdFileName.FileName.Length = (USHORT) Dirent->FileNameLen;
 726     }
 727
 728     //
 729     //  Split the name into name and version strings.
 730     //
 731
 732     CdConvertNameToCdName( IrpContext,
 733                            &Dirent->CdFileName );
 734
 735     //
 736     //  The name length better be non-zero.
 737     //
 738
 739     if (Dirent->CdFileName.FileName.Length == 0) {
 740
 741         CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
 742     }
 743
 744     //
 745     //  If the filename ends with a period then back up one character.
 746     //
 747
 748     if (Dirent->CdFileName.FileName.Buffer[(Dirent->CdFileName.FileName.Length - sizeof( WCHAR )) / 2] == L'.') {
 749
 750         //
 751         //  Slide the version string down.
 752         //
 753
 754         if (Dirent->CdFileName.VersionString.Length != 0) {
 755
 756             PWCHAR NewVersion;
 757
 758             //
 759             //  Start from the position currently containing the separator.
 760             //
 761
 762             NewVersion = Add2Ptr( Dirent->CdFileName.FileName.Buffer,
 763                                   Dirent->CdFileName.FileName.Length,
 764                                   PWCHAR );
 765
 766             //
 767             //  Now overwrite the period.
 768             //
 769
 770             RtlMoveMemory( NewVersion - 1,
 771                            NewVersion,
 772                            Dirent->CdFileName.VersionString.Length + sizeof( WCHAR ));
 773
 774             //
 775             //  Now point to the new version string.
 776             //
 777
 778             Dirent->CdFileName.VersionString.Buffer = NewVersion;
 779         }
 780
 781         //
 782         //  Shrink the filename length.
 783         //
 784
 785         Dirent->CdFileName.FileName.Length -= sizeof( WCHAR );
 786     }
 787
 788     if (!CdIsLegalName( IrpContext, &Dirent->CdFileName.FileName )) {
 789
 790         CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
 791     }
 792
 793     //
 794     //  If this an exact case operation then use the filename exactly.
 795     //
 796
 797     if (!IgnoreCase) {
 798
 799         Dirent->CdCaseFileName = Dirent->CdFileName;
 800
 801     //
 802     //  Otherwise perform our upcase operation.  We already have guaranteed the buffers are
 803     //  there.
 804     //
 805
 806     } else {
 807
 808         Dirent->CdCaseFileName.FileName.Buffer = Add2Ptr( Dirent->CdFileName.FileName.Buffer,
 809                                                           Dirent->CdFileName.FileName.MaximumLength / 2,
 810                                                           PWCHAR);
 811
 812         Dirent->CdCaseFileName.FileName.MaximumLength = Dirent->CdFileName.FileName.MaximumLength / 2;
 813
 814         CdUpcaseName( IrpContext,
 815                       &Dirent->CdFileName,
 816                       &Dirent->CdCaseFileName );
 817     }
 818
 819     return;
 820 }
 821
 822 \f
 823 _Success_(return != FALSE) BOOLEAN
 824 CdFindFile (
 825     _In_ PIRP_CONTEXT IrpContext,
 826     _In_ PFCB Fcb,
 827     _In_ PCD_NAME Name,
 828     _In_ BOOLEAN IgnoreCase,
 829     _Inout_ PFILE_ENUM_CONTEXT FileContext,
 830     _Out_ PCD_NAME *MatchingName
 831     )
 832
 833 /*++
 834
 835 Routine Description:
 836
 837     This routine is called to search a dirctory for a file matching the input
 838     name.  This name has been upcased at this point if this a case-insensitive
 839     search.  The name has been separated into separate name and version strings.
 840     We look for an exact match in the name and only consider the version if
 841     there is a version specified in the search name.
 842
 843 Arguments:
 844
 845     Fcb - Fcb for the directory being scanned.
 846
 847     Name - Name to search for.
 848
 849     IgnoreCase - Indicates the case of the search.
 850
 851     FileContext - File context to use for the search.  This has already been
 852         initialized.
 853
 854     MatchingName - Pointer to buffer containing matching name.  We need this
 855         in case we don't match the name in the directory but match the
 856         short name instead.
 857
 858 Return Value:
 859
 860     BOOLEAN - TRUE if matching entry is found, FALSE otherwise.
 861
 862 --*/
 863
 864 {
 865     PDIRENT Dirent;
 866     ULONG ShortNameDirentOffset;
 867
 868     BOOLEAN Found = FALSE;
 869
 870     PAGED_CODE();
 871
 872     //
 873     //  Make sure there is a stream file for this Fcb.
 874     //
 875
 876     CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
 877
 878     //
 879     //  Check to see whether we need to check for a possible short name.
 880     //
 881
 882     ShortNameDirentOffset = CdShortNameDirentOffset( IrpContext, &Name->FileName );
 883
 884     //
 885     //  Position ourselves at the first entry.
 886     //
 887
 888     CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, Fcb->StreamOffset );
 889
 890     //
 891     //  Loop while there are more entries in this directory.
 892     //
 893
 894     do {
 895
 896         Dirent = &FileContext->InitialDirent->Dirent;
 897
 898         //
 899         //  We only consider files which don't have the associated bit set.
 900         //  We also only look for files.  All directories would already
 901         //  have been found.
 902         //
 903
 904         if (!FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_ASSOC | CD_ATTRIBUTE_DIRECTORY )) {
 905
 906             //
 907             //  Update the name in the current dirent.
 908             //
 909
 910             CdUpdateDirentName( IrpContext, Dirent, IgnoreCase );
 911
 912             //
 913             //  Don't bother with constant entries.
 914             //
 915
 916             if (FlagOn( Dirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY )) {
 917
 918                 continue;
 919             }
 920
 921             //
 922             //  Now check whether we have a name match.
 923             //  We exit the loop if we have a match.
 924             //
 925
 926             if (CdIsNameInExpression( IrpContext,
 927                                       &Dirent->CdCaseFileName,
 928                                       Name,
 929                                       0,
 930                                       TRUE )) {
 931
 932                 *MatchingName = &Dirent->CdCaseFileName;
 933                 Found = TRUE;
 934                 break;
 935             }
 936
 937             //
 938             //  The names didn't match.  If the input name is a possible short
 939             //  name and we are at the correct offset in the directory then
 940             //  check if the short names match.
 941             //
 942
 943             if (((Dirent->DirentOffset >> SHORT_NAME_SHIFT) == ShortNameDirentOffset) &&
 944                 (Name->VersionString.Length == 0) &&
 945                 !CdIs8dot3Name( IrpContext,
 946                                 Dirent->CdFileName.FileName )) {
 947
 948                 //
 949                 //  Create the short name and check for a match.
 950                 //
 951
 952                 CdGenerate8dot3Name( IrpContext,
 953                                      &Dirent->CdCaseFileName.FileName,
 954                                      Dirent->DirentOffset,
 955                                      FileContext->ShortName.FileName.Buffer,
 956                                      &FileContext->ShortName.FileName.Length );
 957
 958                 //
 959                 //  Now check whether we have a name match.
 960                 //  We exit the loop if we have a match.
 961                 //
 962
 963                 if (CdIsNameInExpression( IrpContext,
 964                                           &FileContext->ShortName,
 965                                           Name,
 966                                           0,
 967                                           FALSE )) {
 968
 969                     *MatchingName = &FileContext->ShortName,
 970                     Found = TRUE;
 971                     break;
 972                 }
 973             }
 974         }
 975
 976         //
 977         //  Go to the next initial dirent for a file.
 978         //
 979
 980     } while (CdLookupNextInitialFileDirent( IrpContext, Fcb, FileContext ));
 981
 982     //
 983     //  If we find the file then collect all of the dirents.
 984     //
 985
 986     if (Found) {
 987
 988         CdLookupLastFileDirent( IrpContext, Fcb, FileContext );
 989
 990     }
 991
 992     return Found;
 993 }
 994
 995 \f
 996 BOOLEAN
 997 CdFindDirectory (
 998     _In_ PIRP_CONTEXT IrpContext,
 999     _In_ PFCB Fcb,
1000     _In_ PCD_NAME Name,
1001     _In_ BOOLEAN IgnoreCase,
1002     _Inout_ PFILE_ENUM_CONTEXT FileContext
1003     )
1004
1005 /*++
1006
1007 Routine Description:
1008
1009     This routine is called to search a dirctory for a directory matching the input
1010     name.  This name has been upcased at this point if this a case-insensitive
1011     search.  We look for an exact match in the name and do not look for shortname
1012     equivalents.
1013
1014 Arguments:
1015
1016     Fcb - Fcb for the directory being scanned.
1017
1018     Name - Name to search for.
1019
1020     IgnoreCase - Indicates the case of the search.
1021
1022     FileContext - File context to use for the search.  This has already been
1023         initialized.
1024
1025 Return Value:
1026
1027     BOOLEAN - TRUE if matching entry is found, FALSE otherwise.
1028
1029 --*/
1030
1031 {
1032     PDIRENT Dirent;
1033
1034     BOOLEAN Found = FALSE;
1035
1036     PAGED_CODE();
1037
1038     //
1039     //  Make sure there is a stream file for this Fcb.
1040     //
1041
1042     CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
1043
1044     //
1045     //  Position ourselves at the first entry.
1046     //
1047
1048     CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, Fcb->StreamOffset );
1049
1050     //
1051     //  Loop while there are more entries in this directory.
1052     //
1053
1054     do {
1055
1056         Dirent = &FileContext->InitialDirent->Dirent;
1057
1058         //
1059         //  We only look for directories.  Directories cannot have the
1060         //  associated bit set.
1061         //
1062
1063         if (FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_DIRECTORY )) {
1064
1065             //
1066             //  Update the name in the current dirent.
1067             //
1068
1069             CdUpdateDirentName( IrpContext, Dirent, IgnoreCase );
1070
1071             //
1072             //  Don't bother with constant entries.
1073             //
1074
1075             if (FlagOn( Dirent->Flags, DIRENT_FLAG_CONSTANT_ENTRY )) {
1076
1077                 continue;
1078             }
1079
1080             //
1081             //  Now check whether we have a name match.
1082             //  We exit the loop if we have a match.
1083             //
1084
1085             if (CdIsNameInExpression( IrpContext,
1086                                       &Dirent->CdCaseFileName,
1087                                       Name,
1088                                       0,
1089                                       TRUE )) {
1090
1091                 Found = TRUE;
1092                 break;
1093             }
1094         }
1095
1096         //
1097         //  Go to the next initial dirent.
1098         //
1099
1100     } while (CdLookupNextInitialFileDirent( IrpContext, Fcb, FileContext ));
1101
1102     return Found;
1103 }
1104
1105 \f
1106 _At_(FileContext->ShortName.FileName.MaximumLength, _In_range_(>=, BYTE_COUNT_8_DOT_3))
1107 BOOLEAN
1108 CdFindFileByShortName (
1109     _In_ PIRP_CONTEXT IrpContext,
1110     _In_ PFCB Fcb,
1111     _In_ PCD_NAME Name,
1112     _In_ BOOLEAN IgnoreCase,
1113     _In_ ULONG ShortNameDirentOffset,
1114     _Inout_ PFILE_ENUM_CONTEXT FileContext
1115     )
1116
1117 /*++
1118
1119 Routine Description:
1120
1121     This routine is called to find the file name entry whose short name
1122     is defined by the input DirentOffset.  The dirent offset here is
1123     multiplied by 32 and we look for the dirent begins in this 32 byte offset in
1124     directory.  The minimum dirent length is 34 so we are guaranteed that only
1125     one dirent can begin in each 32 byte block in the directory.
1126
1127 Arguments:
1128
1129     Fcb - Fcb for the directory being scanned.
1130
1131     Name - Name we are trying to match.  We know this contains the tilde
1132         character followed by decimal characters.
1133
1134     IgnoreCase - Indicates whether we need to upcase the long name and
1135         generated short name.
1136
1137     ShortNameDirentOffset - This is the shifted value for the offset of the
1138         name in the directory.
1139
1140     FileContext - This is the initialized file context to use for the search.
1141
1142 Return Value:
1143
1144     BOOLEAN - TRUE if a matching name was found, FALSE otherwise.
1145
1146 --*/
1147
1148 {
1149     BOOLEAN Found = FALSE;
1150     PDIRENT Dirent;
1151
1152     ULONG ThisShortNameDirentOffset;
1153
1154     PAGED_CODE();
1155
1156     //
1157     //  Make sure there is a stream file for this Fcb.
1158     //
1159
1160     CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
1161
1162     //
1163     //  Position ourselves at the start of the directory and update
1164     //
1165     //
1166
1167     CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, Fcb->StreamOffset );
1168
1169     //
1170     //  Loop until we have found the entry or are beyond this dirent.
1171     //
1172
1173     do {
1174
1175         //
1176         //  Compute the short name dirent offset for the current dirent.
1177         //
1178
1179         Dirent = &FileContext->InitialDirent->Dirent;
1180         ThisShortNameDirentOffset = Dirent->DirentOffset >> SHORT_NAME_SHIFT;
1181
1182         //
1183         //  If beyond the target then exit.
1184         //
1185
1186         if (ThisShortNameDirentOffset > ShortNameDirentOffset) {
1187
1188             break;
1189         }
1190
1191         //
1192         //  If equal to the target then check if we have a name match.
1193         //  We will either match or fail here.
1194         //
1195
1196         if (ThisShortNameDirentOffset == ShortNameDirentOffset) {
1197
1198             //
1199             //  If this is an associated file then get out.
1200             //
1201
1202             if (FlagOn( Dirent->DirentFlags, CD_ATTRIBUTE_ASSOC )) {
1203
1204                 break;
1205             }
1206
1207             //
1208             //  Update the name in the dirent and check if it is not
1209             //  an 8.3 name.
1210             //
1211
1212             CdUpdateDirentName( IrpContext, Dirent, IgnoreCase );
1213
1214             if (CdIs8dot3Name( IrpContext,
1215                                Dirent->CdFileName.FileName )) {
1216
1217                 break;
1218             }
1219
1220             //
1221             //  Generate the 8.3 name see if it matches our input name.
1222             //
1223
1224             CdGenerate8dot3Name( IrpContext,
1225                                  &Dirent->CdCaseFileName.FileName,
1226                                  Dirent->DirentOffset,
1227                                  FileContext->ShortName.FileName.Buffer,
1228                                  &FileContext->ShortName.FileName.Length );
1229
1230             //
1231             //  Check if this name matches.
1232             //
1233
1234             if (CdIsNameInExpression( IrpContext,
1235                                       Name,
1236                                       &FileContext->ShortName,
1237                                       0,
1238                                       FALSE )) {
1239
1240                 //
1241                 //  Let our caller know we found an entry.
1242                 //
1243
1244                 Found = TRUE;
1245             }
1246
1247             //
1248             //  Break out of the loop.
1249             //
1250
1251             break;
1252         }
1253
1254         //
1255         //  Continue until there are no more entries.
1256         //
1257
1258     } while (CdLookupNextInitialFileDirent( IrpContext, Fcb, FileContext ));
1259
1260     //
1261     //  If we find the file then collect all of the dirents.
1262     //
1263
1264     if (Found) {
1265
1266         CdLookupLastFileDirent( IrpContext, Fcb, FileContext );
1267
1268     }
1269
1270     return Found;
1271 }
1272
1273 \f
1274 BOOLEAN
1275 CdLookupNextInitialFileDirent (
1276     _In_ PIRP_CONTEXT IrpContext,
1277     _In_ PFCB Fcb,
1278     _Inout_ PFILE_ENUM_CONTEXT FileContext
1279     )
1280
1281 /*++
1282
1283 Routine Description:
1284
1285     This routine is called to walk through the directory until we find the
1286     first possible dirent for file.  We are positioned at some point described
1287     by the FileContext.  We will walk through any remaing dirents for the
1288     current file until we find the first dirent for some subsequent file.
1289
1290     We can be called when we have found just one dirent for a file or all
1291     of them.  We first check the CurrentDirContext.  In the typical
1292     single-extent case this is unused.  Then we look to the InitialDirContext
1293     which must be initialized.
1294
1295     This routine will save the initial DirContext to the PriorDirContext and
1296     clean up any existing DirContext for the Prior or Current positions in
1297     the enumeration context.
1298
1299 Arguments:
1300
1301     Fcb - This is the directory to scan.
1302
1303     FileContext - This is the file enumeration context.  It is currently pointing
1304         at some file in the directory.
1305
1306 Return Value:
1307
1308 --*/
1309
1310 {
1311     PRAW_DIRENT RawDirent;
1312
1313     PDIRENT_ENUM_CONTEXT CurrentDirContext;
1314     PDIRENT_ENUM_CONTEXT TargetDirContext;
1315     PCOMPOUND_DIRENT TempDirent;
1316
1317     BOOLEAN FoundDirent = FALSE;
1318     BOOLEAN FoundLastDirent;
1319
1320     PAGED_CODE();
1321
1322     //
1323     //  Start by saving the initial dirent of the current file as the
1324     //  previous file.
1325     //
1326
1327     TempDirent = FileContext->PriorDirent;
1328     FileContext->PriorDirent = FileContext->InitialDirent;
1329     FileContext->InitialDirent = TempDirent;
1330
1331     //
1332     //  We will use the initial dirent of the prior file unless the
1333     //  previous search returned multiple extents.
1334     //
1335
1336     CurrentDirContext = &FileContext->PriorDirent->DirContext;
1337
1338     if (FlagOn( FileContext->Flags, FILE_CONTEXT_MULTIPLE_DIRENTS )) {
1339
1340         CurrentDirContext = &FileContext->CurrentDirent->DirContext;
1341     }
1342
1343     //
1344     //  Clear all of the flags and file size for the next file.
1345     //
1346
1347     FileContext->Flags = 0;
1348     FileContext->FileSize = 0;
1349
1350     FileContext->ShortName.FileName.Length = 0;
1351
1352     //
1353     //  We always want to store the result into the updated initial dirent
1354     //  context.
1355     //
1356
1357     TargetDirContext = &FileContext->InitialDirent->DirContext;
1358
1359     //
1360     //  Loop until we find the first dirent after the last dirent of the
1361     //  current file.  We may not be at the last dirent for the current file yet
1362     //  so we may walk forward looking for the last and then find the
1363     //  initial dirent for the next file after that.
1364     //
1365
1366     while (TRUE) {
1367
1368         //
1369         //  Remember if the last dirent we visited was the last dirent for
1370         //  a file.
1371         //
1372
1373         RawDirent = CdRawDirent( IrpContext, CurrentDirContext );
1374
1375         FoundLastDirent = !FlagOn( CdRawDirentFlags( IrpContext, RawDirent ), CD_ATTRIBUTE_MULTI );
1376
1377         //
1378         //  Try to find another dirent.
1379         //
1380
1381         FoundDirent = CdLookupNextDirent( IrpContext,
1382                                           Fcb,
1383                                           CurrentDirContext,
1384                                           TargetDirContext );
1385
1386         //
1387         //  Exit the loop if no entry found.
1388         //
1389
1390         if (!FoundDirent) {
1391
1392             break;
1393
1394         }
1395
1396         //
1397         //  Update the in-memory dirent.
1398         //
1399
1400         CdUpdateDirentFromRawDirent( IrpContext,
1401                                      Fcb,
1402                                      TargetDirContext,
1403                                      &FileContext->InitialDirent->Dirent );
1404
1405         //
1406         //  Exit the loop if we had the end for the previous file.
1407         //
1408
1409         if (FoundLastDirent) {
1410
1411             break;
1412         }
1413
1414         //
1415         //  Always use a single dirent from this point on.
1416         //
1417
1418         CurrentDirContext = TargetDirContext;
1419     }
1420
1421     return FoundDirent;
1422 }
1423
1424 \f
1425 VOID
1426 CdLookupLastFileDirent (
1427     _In_ PIRP_CONTEXT IrpContext,
1428     _In_ PFCB Fcb,
1429     _In_ PFILE_ENUM_CONTEXT FileContext
1430     )
1431
1432 /*++
1433
1434 Routine Description:
1435
1436     This routine is called when we've found the matching initial dirent for
1437     a file.  Now we want to find all of the dirents for a file as well as
1438     compute the running total for the file size.
1439
1440     We also go out to the system use area and check whether this is an
1441     XA sector.  In that case we will compute the real file size.
1442
1443     The dirent in the initial compound dirent has been updated from the
1444     raw dirent when this routine is called.
1445
1446 Arguments:
1447
1448     Fcb - Directory containing the entries for the file.
1449
1450     FileContext - Enumeration context for this search.  It currently points
1451         to the first dirent of the file and the in-memory dirent has been
1452         updated.
1453
1454 Return Value:
1455
1456     None.  This routine may raise STATUS_FILE_CORRUPT.
1457
1458 --*/
1459
1460 {
1461     XA_EXTENT_TYPE ExtentType = Form1Data;
1462     PCOMPOUND_DIRENT CurrentCompoundDirent;
1463     PDIRENT CurrentDirent = NULL;
1464
1465     BOOLEAN FirstPass = TRUE;
1466     BOOLEAN FoundDirent;
1467
1468     PAGED_CODE();
1469
1470     //
1471     //  The current dirent to look at is the initial dirent for the file.
1472     //
1473
1474     CurrentCompoundDirent = FileContext->InitialDirent;
1475
1476     //
1477     //  Loop until we reach the last dirent for the file.
1478     //
1479
1480     while (TRUE) {
1481
1482         CurrentDirent = &CurrentCompoundDirent->Dirent;
1483
1484         //
1485         //  Check if this extent has XA sectors.
1486         //
1487
1488         if ((CurrentDirent->SystemUseOffset != 0) &&
1489             FlagOn( Fcb->Vcb->VcbState, VCB_STATE_CDXA ) &&
1490             CdCheckForXAExtent( IrpContext,
1491                                 CdRawDirent( IrpContext, &CurrentCompoundDirent->DirContext ),
1492                                 CurrentDirent )) {
1493
1494             //
1495             //  Any previous dirent must describe XA sectors as well.
1496             //
1497
1498             if (!FirstPass && (ExtentType != CurrentDirent->ExtentType)) {
1499
1500                 CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
1501             }
1502
1503             //
1504             //  If there are XA sectors then the data on the disk must
1505             //  be correctly aligned on sectors and be an integral number of
1506             //  sectors.  Only an issue if the logical block size is not
1507             //  2048.
1508             //
1509
1510             if (Fcb->Vcb->BlockSize != SECTOR_SIZE) {
1511
1512                 //
1513                 //  We will do the following checks.
1514                 //
1515                 //      Data must start on a sector boundary.
1516                 //      Data length must be integral number of sectors.
1517                 //
1518
1519                 if ((SectorBlockOffset( Fcb->Vcb, CurrentDirent->StartingOffset ) != 0) ||
1520                     (SectorBlockOffset( Fcb->Vcb, CurrentDirent->DataLength ) != 0)) {
1521
1522                     CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
1523                 }
1524
1525                 //
1526                 //  If interleaved then both the file unit and interleave
1527                 //  gap must be integral number of sectors.
1528                 //
1529
1530                 if ((CurrentDirent->FileUnitSize != 0) &&
1531                     ((SectorBlockOffset( Fcb->Vcb, CurrentDirent->FileUnitSize ) != 0) ||
1532                      (SectorBlockOffset( Fcb->Vcb, CurrentDirent->InterleaveGapSize ) != 0))) {
1533
1534                     CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
1535                 }
1536             }
1537
1538             //
1539             //  If this is the first dirent then add the bytes for the RIFF
1540             //  header.
1541             //
1542
1543             if (FirstPass) {
1544
1545                 FileContext->FileSize = sizeof( RIFF_HEADER );
1546             }
1547
1548             //
1549             //  Add the size of the mode2-form2 sector for each sector
1550             //  we have here.
1551             //
1552
1553             FileContext->FileSize += Int32x32To64( CurrentDirent->DataLength >> SECTOR_SHIFT,
1554                                                    XA_SECTOR_SIZE);
1555
1556         } else {
1557
1558             //
1559             //  This extent does not have XA sectors.  Any previous dirent
1560             //  better not have XA sectors.
1561             //
1562
1563             if (!FirstPass && (ExtentType != CurrentDirent->ExtentType)) {
1564
1565                 CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
1566             }
1567
1568             //
1569             //  Add these bytes to the file size.
1570             //
1571
1572             FileContext->FileSize += CurrentDirent->DataLength;
1573         }
1574
1575         //
1576         //  If we are at the last dirent then exit.
1577         //
1578
1579         if (!FlagOn( CurrentDirent->DirentFlags, CD_ATTRIBUTE_MULTI )) {
1580
1581             break;
1582         }
1583
1584         //
1585         //  Remember the extent type of the current extent.
1586         //
1587
1588         ExtentType = CurrentDirent->ExtentType;
1589
1590         //
1591         //  Look for the next dirent of the file.
1592         //
1593
1594         FoundDirent = CdLookupNextDirent( IrpContext,
1595                                           Fcb,
1596                                           &CurrentCompoundDirent->DirContext,
1597                                           &FileContext->CurrentDirent->DirContext );
1598
1599         //
1600         //  If we didn't find the entry then this is a corrupt directory.
1601         //
1602
1603         if (!FoundDirent) {
1604
1605             CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
1606         }
1607
1608         //
1609         //  Remember the dirent we just found.
1610         //
1611
1612         CurrentCompoundDirent = FileContext->CurrentDirent;
1613         FirstPass = FALSE;
1614
1615         //
1616         //  Look up all of the dirent information for the given dirent.
1617         //
1618
1619         CdUpdateDirentFromRawDirent( IrpContext,
1620                                      Fcb,
1621                                      &CurrentCompoundDirent->DirContext,
1622                                      &CurrentCompoundDirent->Dirent );
1623
1624         //
1625         //  Set flag to show there were multiple extents.
1626         //
1627
1628         SetFlag( FileContext->Flags, FILE_CONTEXT_MULTIPLE_DIRENTS );
1629     }
1630
1631     return;
1632 }
1633
1634 \f
1635 VOID
1636 CdCleanupFileContext (
1637     _In_ PIRP_CONTEXT IrpContext,
1638     _In_ PFILE_ENUM_CONTEXT FileContext
1639     )
1640
1641 /*++
1642
1643 Routine Description:
1644
1645     This routine is called to cleanup the enumeration context for a file
1646     search in a directory.  We will unpin any remaining Bcbs and free
1647     any allocated buffers.
1648
1649 Arguments:
1650
1651     FileContext - Enumeration context for the file search.
1652
1653 Return Value:
1654
1655     None.
1656
1657 --*/
1658
1659 {
1660     PCOMPOUND_DIRENT CurrentCompoundDirent;
1661     ULONG Count = 2;
1662
1663     PAGED_CODE();
1664
1665     UNREFERENCED_PARAMETER( IrpContext );
1666
1667     //
1668     //  Cleanup the individual compound dirents.
1669     //
1670
1671     do {
1672
1673         CurrentCompoundDirent = &FileContext->Dirents[ Count ];
1674         CdCleanupDirContext( IrpContext, &CurrentCompoundDirent->DirContext );
1675         CdCleanupDirent( IrpContext, &CurrentCompoundDirent->Dirent );
1676
1677     } while (Count--);
1678
1679     return;
1680 }
1681
1682 \f
1683 //
1684 //  Local support routine
1685 //
1686
1687 ULONG
1688 CdCheckRawDirentBounds (
1689     _In_ PIRP_CONTEXT IrpContext,
1690     _In_ PDIRENT_ENUM_CONTEXT DirContext
1691     )
1692
1693 /*++
1694
1695 Routine Description:
1696
1697     This routine takes a Dirent enumeration context and computes the offset
1698     to the next dirent.  A non-zero value indicates the offset within this
1699     sector.  A zero value indicates to move to the next sector.  If the
1700     current dirent does not fit within the sector then we will raise
1701     STATUS_CORRUPT.
1702
1703 Arguments:
1704
1705     DirContext - Enumeration context indicating the current position in
1706         the sector.
1707
1708 Return Value:
1709
1710     ULONG - Offset to the next dirent in this sector or zero if the
1711         next dirent is in the next sector.
1712
1713     This routine will raise on a dirent which does not fit into the
1714     described data buffer.
1715
1716 --*/
1717
1718 {
1719     ULONG NextDirentOffset;
1720     PRAW_DIRENT RawDirent;
1721
1722     PAGED_CODE();
1723
1724     UNREFERENCED_PARAMETER( IrpContext );
1725
1726     //
1727     //  We should always have at least a byte still available in the
1728     //  current buffer.
1729     //
1730
1731     NT_ASSERT( (DirContext->DataLength - DirContext->SectorOffset) >= 1 );
1732
1733     //
1734     //  Get a pointer to the current dirent.
1735     //
1736
1737     RawDirent = CdRawDirent( IrpContext, DirContext );
1738
1739     //
1740     //  If the dirent length is non-zero then look at the current dirent.
1741     //
1742
1743     if (RawDirent->DirLen != 0) {
1744
1745         //
1746         //  Check the following bound for the dirent length.
1747         //
1748         //      - Fits in the available bytes in the sector.
1749         //      - Is at least the minimal dirent size.
1750         //      - Is large enough to hold the file name.
1751         //
1752
1753         if ((RawDirent->DirLen > (DirContext->DataLength - DirContext->SectorOffset)) ||
1754             (RawDirent->DirLen < MIN_RAW_DIRENT_LEN) ||
1755             (RawDirent->DirLen < (MIN_RAW_DIRENT_LEN - 1 + RawDirent->FileIdLen))) {
1756
1757             CdRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR );
1758         }
1759
1760         //
1761         //  Copy the dirent length field.
1762         //
1763
1764         NextDirentOffset = RawDirent->DirLen;
1765
1766         //
1767         //  If we are exactly at the next sector then tell our caller by
1768         //  returning zero.
1769         //
1770
1771         if (NextDirentOffset == (DirContext->DataLength - DirContext->SectorOffset)) {
1772
1773             NextDirentOffset = 0;
1774         }
1775
1776     } else {
1777
1778         NextDirentOffset = 0;
1779     }
1780
1781     return NextDirentOffset;
1782 }
1783
1784 \f
1785 //
1786 //  Local support routine
1787 //
1788
1789 XA_EXTENT_TYPE
1790 CdCheckForXAExtent (
1791     _In_ PIRP_CONTEXT IrpContext,
1792     _In_ PRAW_DIRENT RawDirent,
1793     _Inout_ PDIRENT Dirent
1794     )
1795
1796 /*++
1797
1798 Routine Description:
1799
1800     This routine is called to scan through the system use area to test if
1801     the current dirent has the XA bit set.  The bit in the in-memory
1802     dirent will be set as appropriate.
1803
1804 Arguments:
1805
1806     RawDirent - Pointer to the on-disk dirent.
1807
1808     Dirent - Pointer to the in-memory dirent.  We will update this with the
1809         appropriate XA flag.
1810
1811 Return Value:
1812
1813     XA_EXTENT_TYPE - Type of physical extent for this on disk dirent.
1814
1815 --*/
1816
1817 {
1818     XA_EXTENT_TYPE ExtentType = Form1Data;
1819     PSYSTEM_USE_XA SystemUseArea;
1820
1821     PAGED_CODE();
1822
1823     UNREFERENCED_PARAMETER( IrpContext );
1824
1825     //
1826     //  Check if there is enough space for the XA system use area.
1827     //
1828
1829     if (Dirent->DirentLength - Dirent->SystemUseOffset >= sizeof( SYSTEM_USE_XA )) {
1830
1831         SystemUseArea = Add2Ptr( RawDirent, Dirent->SystemUseOffset, PSYSTEM_USE_XA );
1832
1833         //
1834         //  Check for a valid signature.
1835         //
1836
1837         if (SystemUseArea->Signature == SYSTEM_XA_SIGNATURE) {
1838
1839             //
1840             //  Check for an audio track.
1841             //
1842
1843             if (FlagOn( SystemUseArea->Attributes, SYSTEM_USE_XA_DA )) {
1844
1845                 ExtentType = CDAudio;
1846
1847             } else if (FlagOn( SystemUseArea->Attributes, SYSTEM_USE_XA_FORM2 )) {
1848
1849                 //
1850                 //  Check for XA data.  Note that a number of discs (video CDs)
1851                 //  have files marked as type XA Mode 2 Form 1 (2048 bytes of
1852                 //  user data),  but actually record these sectors as Mode2 Form 2
1853                 //  (2352). We will fail to read these files,  since for M2F1,
1854                 //  a normal read CD command is issued (as per SCSI specs).
1855                 //
1856
1857                 ExtentType = Mode2Form2Data;
1858             }
1859
1860             Dirent->XAAttributes = SystemUseArea->Attributes;
1861             Dirent->XAFileNumber = SystemUseArea->FileNumber;
1862         }
1863     }
1864
1865     Dirent->ExtentType = ExtentType;
1866     return ExtentType;
1867 }
1868
1869
1870