drivers/filesystems/cdfs_new/namesup.c

   1 /*++
   2
   3 Copyright (c) 1991-2000 Microsoft Corporation
   4
   5 Module Name:
   6
   7     NameSup.c
   8
   9 Abstract:
  10
  11     This module implements the Cdfs Name support routines
  12
  13
  14 --*/
  15
  16 #include "CdProcs.h"
  17
  18 //
  19 //  The Bug check file id for this module
  20 //
  21
  22 #define BugCheckFileId                   (CDFS_BUG_CHECK_NAMESUP)
  23
  24 #ifdef ALLOC_PRAGMA
  25 #pragma alloc_text(PAGE, CdConvertBigToLittleEndian)
  26 #pragma alloc_text(PAGE, CdConvertNameToCdName)
  27 #pragma alloc_text(PAGE, CdDissectName)
  28 #pragma alloc_text(PAGE, CdGenerate8dot3Name)
  29 #pragma alloc_text(PAGE, CdFullCompareNames)
  30 #pragma alloc_text(PAGE, CdIsLegalName)
  31 #pragma alloc_text(PAGE, CdIs8dot3Name)
  32 #pragma alloc_text(PAGE, CdIsNameInExpression)
  33 #pragma alloc_text(PAGE, CdShortNameDirentOffset)
  34 #pragma alloc_text(PAGE, CdUpcaseName)
  35 #endif
  36
  37 \f
  38 _Post_satisfies_(_Old_(CdName->FileName.Length) >=
  39                  CdName->FileName.Length + CdName->VersionString.Length)
  40 VOID
  41 CdConvertNameToCdName (
  42     _In_ PIRP_CONTEXT IrpContext,
  43     _Inout_ PCD_NAME CdName
  44     )
  45
  46 /*++
  47
  48 Routine Description:
  49
  50     This routine is called to convert a string of bytes into a CdName.
  51
  52     The full name is already in the CdName structure in the FileName field.
  53     We split this into the filename and version strings.
  54
  55 Arguments:
  56
  57     CdName - Pointer to CdName structure to update.
  58
  59 Return Value:
  60
  61     None.
  62
  63 --*/
  64
  65 {
  66     ULONG NameLength = 0;
  67     PWCHAR CurrentCharacter = CdName->FileName.Buffer;
  68
  69     PAGED_CODE();
  70
  71     UNREFERENCED_PARAMETER( IrpContext );
  72
  73     //
  74     //  Look for a separator character.
  75     //
  76
  77     while ((NameLength < CdName->FileName.Length) &&
  78            (*CurrentCharacter != L';')) {
  79
  80         CurrentCharacter += 1;
  81         NameLength += 2;
  82     }
  83
  84     //
  85     //  If there is at least one more character after a possible separator then it
  86     //  and all following characters are part of the version string.
  87     //
  88
  89     CdName->VersionString.Length = 0;
  90     if (NameLength + sizeof( WCHAR ) < CdName->FileName.Length) {
  91
  92         CdName->VersionString.MaximumLength =
  93         CdName->VersionString.Length = (USHORT) (CdName->FileName.Length - NameLength - sizeof( WCHAR ));
  94         CdName->VersionString.Buffer = Add2Ptr( CdName->FileName.Buffer,
  95                                                 NameLength + sizeof( WCHAR ),
  96                                                 PWCHAR );
  97     }
  98
  99     //
 100     //  Now update the filename portion of the name.
 101     //
 102
 103     CdName->FileName.Length = (USHORT) NameLength;
 104
 105     return;
 106 }
 107
 108 \f
 109 VOID
 110 CdConvertBigToLittleEndian (
 111     _In_ PIRP_CONTEXT IrpContext,
 112     _In_reads_bytes_(ByteCount) PCHAR BigEndian,
 113     _In_ ULONG ByteCount,
 114     _Out_writes_bytes_(ByteCount) PCHAR LittleEndian
 115     )
 116
 117 /*++
 118
 119 Routine Description:
 120
 121     This routine is called to convert a unicode string in big endian to
 122     little endian.  We start by copying all of the source bytes except
 123     the first.  This will put the low order bytes in the correct position.
 124     We then copy each high order byte in its correct position.
 125
 126 Arguments:
 127
 128     BigEndian - Pointer to the string of big endian characters.
 129
 130     ByteCount - Number of unicode characters in this string.
 131
 132     LittleEndian - Pointer to array to store the little endian characters.
 133
 134 Return Value:
 135
 136     None.
 137
 138 --*/
 139
 140 {
 141     ULONG RemainingByteCount = ByteCount;
 142
 143     PCHAR Source = BigEndian;
 144     PCHAR Destination = LittleEndian;
 145
 146     PAGED_CODE();
 147
 148     //
 149     //  If the byte count isn't an even number then the disk is corrupt.
 150     //
 151
 152     if (FlagOn( ByteCount, 1 )) {
 153
 154         CdRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR );
 155     }
 156
 157     //
 158     //  Start by copy the low-order bytes into the correct position.  Do
 159     //  this by skipping the first byte in the BigEndian string.
 160     //
 161
 162     RtlCopyMemory( Destination,
 163                    Source + 1,
 164                    RemainingByteCount - 1 );
 165
 166     //
 167     //  Now move the high-order bytes into position.
 168     //
 169
 170     Destination += 1;
 171
 172     while (RemainingByteCount != 0) {
 173
 174 #pragma prefast(push)
 175 #pragma prefast(suppress:26014, "RemainingByteCount is even")
 176         *Destination = *Source;
 177 #pragma prefast(pop)
 178
 179         Source += 2;
 180         Destination += 2;
 181
 182         RemainingByteCount -= 2;
 183     }
 184
 185     return;
 186 }
 187
 188 \f
 189 VOID
 190 CdUpcaseName (
 191     _In_ PIRP_CONTEXT IrpContext,
 192     _In_ PCD_NAME Name,
 193     _Inout_ PCD_NAME UpcaseName
 194     )
 195
 196 /*++
 197
 198 Routine Description:
 199
 200     This routine is called to upcase a CdName structure.  We will do both
 201     the filename and version strings.
 202
 203 Arguments:
 204
 205     Name - This is the mixed case version of the name.
 206
 207     UpcaseName - This is the destination for the upcase operation.
 208
 209 Return Value:
 210
 211     None.  This routine will raise all errors.
 212
 213 --*/
 214
 215 {
 216     NTSTATUS Status;
 217
 218     PAGED_CODE();
 219
 220     UNREFERENCED_PARAMETER( IrpContext );
 221
 222     //
 223     //  If the name structures are different then initialize the different components.
 224     //
 225
 226     if (Name != UpcaseName) {
 227
 228         //
 229         //  Initialize the version string portion of the name.
 230         //
 231
 232         UpcaseName->VersionString.Length = 0;
 233
 234         if (Name->VersionString.Length != 0) {
 235
 236             UpcaseName->VersionString.MaximumLength =
 237             UpcaseName->VersionString.Length = Name->VersionString.Length;
 238
 239             //
 240             //  Initially set the buffer to point to where we need to insert
 241             //  the separator.
 242             //
 243
 244             UpcaseName->VersionString.Buffer = Add2Ptr( UpcaseName->FileName.Buffer,
 245                                                         Name->FileName.Length,
 246                                                         PWCHAR );
 247
 248             //
 249             //  We are currently pointing to the location to store the separator.
 250             //  Store the ';' and then move to the next character to
 251             //  copy the data.
 252             //
 253
 254 #pragma prefast( suppress:26015, "CD_NAME structures have two UNICODE_STRING structures pointing to the same allocation. there is no way to tell prefast this is the case and that the allocation is always big enough.");
 255             *(UpcaseName->VersionString.Buffer) = L';';
 256
 257             UpcaseName->VersionString.Buffer += 1;
 258         }
 259     }
 260
 261     //
 262     //  Upcase the string using the correct upcase routine.
 263     //
 264
 265     Status = RtlUpcaseUnicodeString( &UpcaseName->FileName,
 266                                      &Name->FileName,
 267                                      FALSE );
 268
 269     //
 270     //  This should never fail.
 271     //
 272
 273     NT_ASSERT( Status == STATUS_SUCCESS );
 274     __analysis_assert( Status == STATUS_SUCCESS );
 275
 276     if (Name->VersionString.Length != 0) {
 277
 278         Status = RtlUpcaseUnicodeString( &UpcaseName->VersionString,
 279                                          &Name->VersionString,
 280                                          FALSE );
 281
 282         //
 283         //  This should never fail.
 284         //
 285
 286         NT_ASSERT( Status == STATUS_SUCCESS );
 287         __analysis_assert( Status == STATUS_SUCCESS );
 288     }
 289
 290     return;
 291 }
 292
 293 \f
 294 VOID
 295 CdDissectName (
 296     _In_ PIRP_CONTEXT IrpContext,
 297     _Inout_ PUNICODE_STRING RemainingName,
 298     _Out_ PUNICODE_STRING FinalName
 299     )
 300
 301 /*++
 302
 303 Routine Description:
 304
 305     This routine is called to strip off leading components of the name strings.  We search
 306     for either the end of the string or separating characters.  The input remaining
 307     name strings should have neither a trailing or leading backslash.
 308
 309 Arguments:
 310
 311     RemainingName - Remaining name.
 312
 313     FinalName - Location to store next component of name.
 314
 315 Return Value:
 316
 317     None.
 318
 319 --*/
 320
 321 {
 322     ULONG NameLength;
 323     PWCHAR NextWchar;
 324
 325     PAGED_CODE();
 326
 327     UNREFERENCED_PARAMETER( IrpContext );
 328
 329     //
 330     //  Find the offset of the next component separators.
 331     //
 332
 333     for (NameLength = 0, NextWchar = RemainingName->Buffer;
 334          (NameLength < RemainingName->Length) && (*NextWchar != L'\\');
 335          NameLength += sizeof( WCHAR) , NextWchar += 1);
 336
 337     //
 338     //  Adjust all the strings by this amount.
 339     //
 340
 341     FinalName->Buffer = RemainingName->Buffer;
 342
 343     FinalName->MaximumLength = FinalName->Length = (USHORT) NameLength;
 344
 345     //
 346     //  If this is the last component then set the RemainingName lengths to zero.
 347     //
 348
 349     if (NameLength == RemainingName->Length) {
 350
 351         RemainingName->Length = 0;
 352
 353     //
 354     //  Otherwise we adjust the string by this amount plus the separating character.
 355     //
 356
 357     } else {
 358
 359         RemainingName->MaximumLength -= (USHORT) (NameLength + sizeof( WCHAR ));
 360         RemainingName->Length -= (USHORT) (NameLength + sizeof( WCHAR ));
 361         RemainingName->Buffer = Add2Ptr( RemainingName->Buffer,
 362                                          NameLength + sizeof( WCHAR ),
 363                                          PWCHAR );
 364     }
 365
 366     return;
 367 }
 368
 369 \f
 370 BOOLEAN
 371 CdIsLegalName (
 372     _In_ PIRP_CONTEXT IrpContext,
 373     _In_ PUNICODE_STRING FileName
 374     )
 375
 376 /*++
 377
 378 Routine Description:
 379
 380     This routine checks if the name is a legal ISO 9660 name.
 381
 382 Arguments:
 383
 384     FileName - String of bytes containing the name.
 385
 386 Return Value:
 387
 388     BOOLEAN - TRUE if this name is a legal, FALSE otherwise.
 389
 390 --*/
 391
 392 {
 393     PWCHAR Wchar;
 394
 395     PAGED_CODE();
 396
 397     UNREFERENCED_PARAMETER( IrpContext );
 398
 399     //
 400     //  Check if name corresponds to a legal file name.
 401     //
 402
 403     for (Wchar = FileName->Buffer;
 404          Wchar < Add2Ptr( FileName->Buffer, FileName->Length, PWCHAR );
 405          Wchar++) {
 406
 407         if ((*Wchar < 0xff) &&
 408             !FsRtlIsAnsiCharacterLegalHpfs( *Wchar, FALSE ) &&
 409             (*Wchar != L'"') &&
 410             (*Wchar != L'<') &&
 411             (*Wchar != L'>') &&
 412             (*Wchar != L'|')) {
 413
 414             return FALSE;
 415         }
 416     }
 417
 418     return TRUE;
 419 }
 420
 421 \f
 422 BOOLEAN
 423 CdIs8dot3Name (
 424     _In_ PIRP_CONTEXT IrpContext,
 425     _In_ UNICODE_STRING FileName
 426     )
 427
 428 /*++
 429
 430 Routine Description:
 431
 432     This routine checks if the name follows the 8.3 name conventions.  We check for
 433     the name length and whether the characters are valid.
 434
 435 Arguments:
 436
 437     FileName - String of bytes containing the name.
 438
 439 Return Value:
 440
 441     BOOLEAN - TRUE if this name is a legal 8.3 name, FALSE otherwise.
 442
 443 --*/
 444
 445 {
 446     CHAR DbcsNameBuffer[ BYTE_COUNT_8_DOT_3 ];
 447     STRING DbcsName = {0};
 448
 449     PWCHAR NextWchar;
 450     ULONG Count;
 451
 452     ULONG DotCount = 0;
 453     BOOLEAN LastCharDot = FALSE;
 454
 455     PAGED_CODE();
 456
 457     UNREFERENCED_PARAMETER( IrpContext );
 458
 459     //
 460     //  The length must be less than 24 bytes.
 461     //
 462
 463     NT_ASSERT( FileName.Length != 0 );
 464     if (FileName.Length > BYTE_COUNT_8_DOT_3) {
 465
 466         return FALSE;
 467     }
 468
 469     //
 470     //  Walk though and check for a space character.
 471     //
 472
 473     NextWchar = FileName.Buffer;
 474     Count = 0;
 475
 476     do {
 477
 478         //
 479         //  No spaces allowed.
 480         //
 481
 482         if (*NextWchar == L' ') { return FALSE; }
 483
 484         if (*NextWchar == L'.') {
 485
 486             //
 487             //  Not an 8.3 name if more than 1 dot or more than 8 characters
 488             //  remaining.  (It is legal for the dot to be in the ninth
 489             //  position)
 490             //
 491
 492             if ((DotCount > 0) ||
 493                 (Count > 8 * sizeof( WCHAR ))) {
 494
 495                 return FALSE;
 496             }
 497
 498             DotCount += 1;
 499             LastCharDot = TRUE;
 500
 501         } else {
 502
 503             LastCharDot = FALSE;
 504         }
 505
 506         Count += 2;
 507         NextWchar += 1;
 508
 509     } while (Count < FileName.Length);
 510
 511     //
 512     //  Go ahead and truncate the dot if at the end.
 513     //
 514
 515     if (LastCharDot) {
 516
 517         FileName.Length -= sizeof( WCHAR );
 518     }
 519
 520     //
 521     //  Create an Oem name to use to check for a valid short name.
 522     //
 523
 524     DbcsName.MaximumLength = BYTE_COUNT_8_DOT_3;
 525     DbcsName.Buffer = DbcsNameBuffer;
 526
 527     if (!NT_SUCCESS( RtlUnicodeStringToCountedOemString( &DbcsName,
 528                                                          &FileName,
 529                                                          FALSE ))) {
 530
 531         return FALSE;
 532     }
 533
 534     //
 535     //  We have now initialized the Oem string.  Call the FsRtl package to check for a
 536     //  valid FAT name.
 537     //
 538
 539     return FsRtlIsFatDbcsLegal( DbcsName, FALSE, FALSE, FALSE );
 540 }
 541
 542 \f
 543 VOID
 544 CdGenerate8dot3Name (
 545     _In_ PIRP_CONTEXT IrpContext,
 546     _In_ PUNICODE_STRING FileName,
 547     _In_ ULONG DirentOffset,
 548     _Out_writes_bytes_to_(BYTE_COUNT_8_DOT_3, *ShortByteCount) PWCHAR ShortFileName,
 549     _Out_ PUSHORT ShortByteCount
 550     )
 551
 552 /*++
 553
 554 Routine Description:
 555
 556     This routine is called to generate a short name from the given long name.  We will
 557     generate a short name from the given long name.
 558
 559     We go through the following steps to make this conversion.
 560
 561         1 - Generate the generic short name.  This will also be in unicode format.
 562
 563         2 - Build the string representation of the dirent offset.
 564
 565         3 - Build the biased short name string by combining the generic short name with
 566             the dirent offset string.
 567
 568         4 - Copy the final unicode string back to our caller's buffer.
 569
 570 Arguments:
 571
 572     FileName - String of bytes containing the name.
 573
 574     DirentOffset - Offset in the directory for this filename.  We incorporate the offset into
 575         the short name by dividing this by 32 and prepending a tilde character to the
 576         digit character.  We then append this to the base of the generated short name.
 577
 578     ShortFileName - Pointer to the buffer to store the short name into.
 579
 580     ShortByteCount - Address to store the number of bytes in the short name.
 581
 582 Return Value:
 583
 584     None.
 585
 586 --*/
 587
 588 {
 589     NTSTATUS Status;
 590
 591     UNICODE_STRING ShortName;
 592     UNICODE_STRING BiasedShortName;
 593     WCHAR ShortNameBuffer[ BYTE_COUNT_8_DOT_3 / sizeof( WCHAR ) ] = {0};
 594     WCHAR BiasedShortNameBuffer[ BYTE_COUNT_8_DOT_3 / sizeof( WCHAR ) ];
 595
 596     GENERATE_NAME_CONTEXT NameContext;
 597
 598     ULONG BiasedDirentOffset;
 599
 600     ULONG MaximumBaseBytes;
 601     ULONG BaseNameOffset;
 602
 603     PWCHAR NextWchar;
 604     WCHAR ThisWchar;
 605     USHORT Length;
 606
 607     BOOLEAN FoundTilde = FALSE;
 608
 609     OEM_STRING OemName = {0};
 610     USHORT OemNameOffset = 0;
 611     BOOLEAN OverflowBuffer = FALSE;
 612
 613     PAGED_CODE();
 614
 615     //
 616     //  Initialize the short string to use the input buffer.
 617     //
 618
 619     ShortName.Buffer = ShortNameBuffer;
 620     ShortName.MaximumLength = BYTE_COUNT_8_DOT_3;
 621
 622     //
 623     //  Initialize the name context.
 624     //
 625
 626     RtlZeroMemory( &NameContext, sizeof( GENERATE_NAME_CONTEXT ));
 627
 628     //
 629     //  We now have the unicode name for the input string.  Go ahead and generate
 630     //  the short name.
 631     //
 632
 633     RtlGenerate8dot3Name( FileName, TRUE, &NameContext, &ShortName );
 634
 635     //
 636     //  We now have the generic short name.  We want incorporate the dirent offset
 637     //  into the name in order to reduce the chance of name conflicts.  We will use
 638     //  a tilde character followed by a character representation of the dirent offset.
 639     //  This will be the hexadecimal representation of the dirent offset in the directory.
 640     //  It is actuall this offset divided by 32 since we don't need the full
 641     //  granularity.
 642     //
 643
 644     BiasedDirentOffset = DirentOffset >> SHORT_NAME_SHIFT;
 645
 646     //
 647     //  Point to a local buffer to store the offset string.  We start
 648     //  at the end of the buffer and work backwards.
 649     //
 650
 651     NextWchar = Add2Ptr( BiasedShortNameBuffer,
 652                          BYTE_COUNT_8_DOT_3,
 653                          PWCHAR );
 654
 655     BiasedShortName.MaximumLength = BYTE_COUNT_8_DOT_3;
 656
 657     //
 658     //  Generate an OEM version of the string so that we can check for double
 659     //  byte characters.
 660     //
 661
 662     Status = RtlUnicodeStringToOemString(&OemName, &ShortName, TRUE);
 663
 664     //
 665     //  If this failed, bail out. Don't expect any problems other than no mem.
 666     //
 667
 668     if (!NT_SUCCESS( Status)) {
 669
 670         NT_ASSERT( STATUS_INSUFFICIENT_RESOURCES == Status);
 671         CdRaiseStatus( IrpContext, Status);
 672     }
 673
 674     Length = 0;
 675
 676     //
 677     //  Now add the characters for the dirent offset.  We need to start
 678     //  from the least significant digit and work backwards.
 679     //
 680
 681     do {
 682
 683         NextWchar -= 1;
 684
 685         ThisWchar = (WCHAR) (BiasedDirentOffset & 0x0000000f);
 686
 687         //
 688         //  Store in the next character.  Bias against either '0' or 'A'
 689         //
 690
 691         if (ThisWchar <= 9) {
 692
 693             *NextWchar = ThisWchar + L'0';
 694
 695         } else {
 696
 697             *NextWchar = ThisWchar + L'A' - 0xA;
 698         }
 699
 700         Length += sizeof( WCHAR );
 701
 702         //
 703         //  Shift out the low 4 bits of the offset.
 704         //
 705
 706         BiasedDirentOffset >>= 4;
 707
 708     } while (BiasedDirentOffset != 0);
 709
 710     //
 711     //  Now store in the tilde character.
 712     //
 713
 714     NextWchar -= 1;
 715     *NextWchar = L'~';
 716     Length += sizeof( WCHAR );
 717
 718     //
 719     //  Set the length of this string.
 720     //
 721
 722     BiasedShortName.Length = Length;
 723     BiasedShortName.Buffer = NextWchar;
 724
 725     //
 726     //  Figure out the maximum number of characters we can copy of the base
 727     //  name.  We subract the number of characters in the dirent string from 8.
 728     //  We will copy this many characters or stop when we reach a '.' character
 729     //  or a '~' character in the name.
 730     //
 731
 732     MaximumBaseBytes = 16 - Length;
 733
 734     BaseNameOffset = 0;
 735
 736     //
 737     //  Keep copying from the base name until we hit a '.', '~'  or the end of
 738     //  the short name.
 739     //
 740
 741     NextWchar = ShortFileName;
 742     Length = 0;
 743
 744     while ((BaseNameOffset < ShortName.Length) &&
 745            (ShortName.Buffer[BaseNameOffset / 2] != L'.')) {
 746
 747         //
 748         //  Remember if we found a tilde character in the short name,
 749         //  so we don't copy it or anything following it.
 750         //
 751
 752         if (ShortName.Buffer[BaseNameOffset / 2] == L'~') {
 753
 754             FoundTilde = TRUE;
 755         }
 756
 757         //
 758         // We need to consider the DBCS code page,  because Unicode characters
 759         // may use 2 bytes as DBCS characters.
 760         //
 761
 762 #pragma prefast(push)
 763 #pragma prefast(suppress:26014, "OemNameOffset <= BaseNameOffset throughout this loop; OemName buffer previously allocated based on ShortName's length.")
 764         if (FsRtlIsLeadDbcsCharacter(OemName.Buffer[OemNameOffset])) {
 765 #pragma prefast(pop)
 766
 767             OemNameOffset += 2;
 768
 769             if ((OemNameOffset + (BiasedShortName.Length / sizeof(WCHAR))) > 8)  {
 770
 771                 OverflowBuffer = TRUE;
 772             }
 773         }
 774         else  {
 775
 776             OemNameOffset++;
 777         }
 778
 779         //
 780         //  Only copy the bytes if we still have space for the dirent string.
 781         //
 782
 783         if (!FoundTilde && !OverflowBuffer && (BaseNameOffset < MaximumBaseBytes)) {
 784
 785             *NextWchar = ShortName.Buffer[BaseNameOffset / 2];
 786             Length += sizeof( WCHAR );
 787             NextWchar += 1;
 788         }
 789
 790         BaseNameOffset += 2;
 791     }
 792
 793     RtlFreeOemString(&OemName);
 794
 795     //
 796     //  Now copy the dirent string into the biased name buffer.
 797     //
 798
 799 #pragma prefast(push)
 800     RtlCopyMemory( NextWchar,
 801                    BiasedShortName.Buffer,
 802                    BiasedShortName.Length );
 803 #pragma prefast(pop)
 804
 805     Length += BiasedShortName.Length;
 806     NextWchar += (BiasedShortName.Length / sizeof( WCHAR ));
 807
 808     //
 809     //  Now copy any remaining bytes over to the biased short name.
 810     //
 811
 812     if (BaseNameOffset != ShortName.Length) {
 813
 814         RtlCopyMemory( NextWchar,
 815                        &ShortName.Buffer[BaseNameOffset / 2],
 816                        ShortName.Length - BaseNameOffset );
 817
 818         Length += (ShortName.Length - (USHORT) BaseNameOffset);
 819     }
 820
 821     //
 822     //  The final short name is stored in the user's buffer.
 823     //
 824
 825     *ShortByteCount = Length;
 826 }
 827
 828 \f
 829 BOOLEAN
 830 CdIsNameInExpression (
 831     _In_ PIRP_CONTEXT IrpContext,
 832     _In_ PCD_NAME CurrentName,
 833     _In_ PCD_NAME SearchExpression,
 834     _In_ ULONG  WildcardFlags,
 835     _In_ BOOLEAN CheckVersion
 836     )
 837
 838 /*++
 839
 840 Routine Description:
 841
 842     This routine will compare two CdName strings.  We assume that if this
 843     is to be a case-insensitive search then they are already upcased.
 844
 845     We compare the filename portions of the name and if they match we
 846     compare the version strings if requested.
 847
 848 Arguments:
 849
 850     CurrentName - Filename from the disk.
 851
 852     SearchExpression - Filename expression to use for match.
 853
 854     WildcardFlags - Flags field which indicates which parts of the
 855         search expression might have wildcards.  These flags are the
 856         same as in the Ccb flags field.
 857
 858     CheckVersion - Indicates whether we should check both the name and the
 859         version strings or just the name.
 860
 861 Return Value:
 862
 863     BOOLEAN - TRUE if the expressions match, FALSE otherwise.
 864
 865 --*/
 866
 867 {
 868     BOOLEAN Match = TRUE;
 869     PAGED_CODE();
 870
 871     UNREFERENCED_PARAMETER( IrpContext );
 872
 873     //
 874     //  If there are wildcards in the expression then we call the
 875     //  appropriate FsRtlRoutine.
 876     //
 877
 878     if (FlagOn( WildcardFlags, CCB_FLAG_ENUM_NAME_EXP_HAS_WILD )) {
 879
 880         Match = FsRtlIsNameInExpression( &SearchExpression->FileName,
 881                                          &CurrentName->FileName,
 882                                          FALSE,
 883                                          NULL );
 884
 885     //
 886     //  Otherwise do a direct memory comparison for the name string.
 887     //
 888
 889     } else {
 890
 891         if ((CurrentName->FileName.Length != SearchExpression->FileName.Length) ||
 892             (!RtlEqualMemory( CurrentName->FileName.Buffer,
 893                               SearchExpression->FileName.Buffer,
 894                               CurrentName->FileName.Length ))) {
 895
 896             Match = FALSE;
 897         }
 898     }
 899
 900     //
 901     //  Check the version numbers if requested by the user and we have a
 902     //  match on the name and the version number is present.
 903     //
 904
 905     if (Match && CheckVersion && SearchExpression->VersionString.Length &&
 906         !FlagOn( WildcardFlags, CCB_FLAG_ENUM_VERSION_MATCH_ALL )) {
 907
 908         //
 909         //  If there are wildcards in the expression then call the
 910         //  appropriate search expression.
 911         //
 912
 913         if (FlagOn( WildcardFlags, CCB_FLAG_ENUM_VERSION_EXP_HAS_WILD )) {
 914
 915             Match = FsRtlIsNameInExpression( &SearchExpression->VersionString,
 916                                              &CurrentName->VersionString,
 917                                              FALSE,
 918                                              NULL );
 919
 920         //
 921         //  Otherwise do a direct memory comparison for the name string.
 922         //
 923
 924         } else {
 925
 926             if ((CurrentName->VersionString.Length != SearchExpression->VersionString.Length) ||
 927                 (!RtlEqualMemory( CurrentName->VersionString.Buffer,
 928                                   SearchExpression->VersionString.Buffer,
 929                                   CurrentName->VersionString.Length ))) {
 930
 931                 Match = FALSE;
 932             }
 933         }
 934     }
 935
 936     return Match;
 937 }
 938
 939 \f
 940 ULONG
 941 CdShortNameDirentOffset (
 942     _In_ PIRP_CONTEXT IrpContext,
 943     _In_ PUNICODE_STRING Name
 944     )
 945
 946 /*++
 947
 948 Routine Description:
 949
 950     This routine is called to examine a name to see if the dirent offset string is contained.
 951     This consists of a tilde character followed by the offset represented as a hexadecimal
 952     characters.  We don't do any other checks to see if this is a short name.  We
 953     catch that later outside this routine.
 954
 955 Arguments:
 956
 957     Name - This is the CdName to examine.
 958
 959 Return Value:
 960
 961     ULONG - MAXULONG if there is no valid dirent offset string embedded, otherwise the
 962         convert the value to numeric form.
 963
 964 --*/
 965
 966 {
 967     ULONG ResultOffset = MAXULONG;
 968     ULONG RemainingByteCount = Name->Length;
 969
 970     BOOLEAN FoundTilde = FALSE;
 971
 972     PWCHAR NextWchar;
 973
 974     PAGED_CODE();
 975
 976     UNREFERENCED_PARAMETER( IrpContext );
 977
 978     //
 979     //  Walk through the name until we either reach the end of the name
 980     //  or find a tilde character.
 981     //
 982
 983     for (NextWchar = Name->Buffer;
 984          RemainingByteCount != 0;
 985          NextWchar += 1, RemainingByteCount -= sizeof( WCHAR )) {
 986
 987         //
 988         //  Check if this is a dot.  Stop constructing any string if
 989         //  we found a dot.
 990         //
 991
 992         if (*NextWchar == L'.') {
 993
 994             break;
 995         }
 996
 997         //
 998         //  If we already found a tilde then check this character as a
 999         //  valid character.  It must be a digit or A to F.
1000         //
1001
1002         if (FoundTilde) {
1003
1004             if ((*NextWchar < L'0') ||
1005                 (*NextWchar > L'F') ||
1006                 ((*NextWchar > L'9') && (*NextWchar < 'A'))) {
1007
1008                 ResultOffset = MAXULONG;
1009                 break;
1010             }
1011
1012             //
1013             //  Shift the result by 4 bits and add in this new character.
1014             //
1015
1016             ResultOffset <<= 4;
1017
1018             if (*NextWchar < L'A') {
1019
1020                 ResultOffset += *NextWchar - L'0';
1021
1022             } else {
1023
1024                 ResultOffset += (*NextWchar - L'A') + 10;
1025             }
1026
1027             continue;
1028         }
1029
1030         //
1031         //  If this is a tilde then start building the dirent string.
1032         //
1033
1034         if (*NextWchar == L'~') {
1035
1036             FoundTilde = TRUE;
1037             ResultOffset = 0;
1038         }
1039     }
1040
1041     return ResultOffset;
1042 }
1043
1044 \f
1045 //
1046 //  Local support routine
1047 //
1048
1049 FSRTL_COMPARISON_RESULT
1050 CdFullCompareNames (
1051     _In_ PIRP_CONTEXT IrpContext,
1052     _In_ PUNICODE_STRING NameA,
1053     _In_ PUNICODE_STRING NameB
1054     )
1055
1056 /*++
1057
1058 Routine Description:
1059
1060     This function compares two names as fast as possible.  Note that since
1061     this comparison is case sensitive we can do a direct memory comparison.
1062
1063 Arguments:
1064
1065     NameA & NameB - The names to compare.
1066
1067 Return Value:
1068
1069     COMPARISON - returns
1070
1071         LessThan    if NameA < NameB lexicalgraphically,
1072         GreaterThan if NameA > NameB lexicalgraphically,
1073         EqualTo     if NameA is equal to NameB
1074
1075 --*/
1076
1077 {
1078     SIZE_T i;
1079     ULONG MinLength = NameA->Length;
1080     FSRTL_COMPARISON_RESULT Result = LessThan;
1081
1082     PAGED_CODE();
1083
1084     UNREFERENCED_PARAMETER( IrpContext );
1085
1086     //
1087     //  Figure out the minimum of the two lengths
1088     //
1089
1090     if (NameA->Length > NameB->Length) {
1091
1092         MinLength = NameB->Length;
1093         Result = GreaterThan;
1094
1095     } else if (NameA->Length == NameB->Length) {
1096
1097         Result = EqualTo;
1098     }
1099
1100     //
1101     //  Loop through looking at all of the characters in both strings
1102     //  testing for equalilty, less than, and greater than
1103     //
1104
1105     i = RtlCompareMemory( NameA->Buffer, NameB->Buffer, MinLength );
1106
1107     if (i < MinLength) {
1108
1109         //
1110         //  We know the offset of the first character which is different.
1111         //
1112
1113         return ((NameA->Buffer[ i / 2 ] < NameB->Buffer[ i / 2 ]) ?
1114                  LessThan :
1115                  GreaterThan);
1116     }
1117
1118     //
1119     //  The names match up to the length of the shorter string.
1120     //  The shorter string lexically appears first.
1121     //
1122
1123     return Result;
1124 }
1125
1126
1127