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