[dchapyshev] 72835: [NTOS:FSRTL] Rework FsRtlIsNameInExpressionPrivate for correct parsing some expressions * Fixes 1 test for kmtest:FsRtlExpression and 15 tests for kernel32:file

Author: dchapyshev
Date: Tue Sep 27 23:00:20 2016
New Revision: 72835

URL: http://svn.reactos.org/svn/reactos?rev=72835&view=rev
Log:
[NTOS:FSRTL] Rework FsRtlIsNameInExpressionPrivate for correct parsing some expressions

* Fixes 1 test for kmtest:FsRtlExpression and 15 tests for kernel32:file

Modified:
    trunk/reactos/ntoskrnl/fsrtl/name.c

Modified: trunk/reactos/ntoskrnl/fsrtl/name.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/fsrtl/name.c?rev=…
==============================================================================
--- trunk/reactos/ntoskrnl/fsrtl/name.c	[iso-8859-1] (original)
+++ trunk/reactos/ntoskrnl/fsrtl/name.c	[iso-8859-1] Tue Sep 27 23:00:20 2016
@@ -23,13 +23,14 @@
                                IN BOOLEAN IgnoreCase,
                                IN PWCHAR UpcaseTable OPTIONAL)
 {
-    SHORT StarFound = -1, DosStarFound = -1;
-    USHORT BackTrackingBuffer[5], DosBackTrackingBuffer[5];
-    PUSHORT BackTracking = BackTrackingBuffer, DosBackTracking = DosBackTrackingBuffer;
-    SHORT BackTrackingSize = RTL_NUMBER_OF(BackTrackingBuffer);
-    SHORT DosBackTrackingSize = RTL_NUMBER_OF(DosBackTrackingBuffer);
+    USHORT Offset, Position, BackTrackingPosition, OldBackTrackingPosition;
+    USHORT BackTrackingBuffer[16], OldBackTrackingBuffer[16] = {0};
+    PUSHORT BackTrackingSwap, BackTracking = BackTrackingBuffer, OldBackTracking =
OldBackTrackingBuffer;
     UNICODE_STRING IntExpression;
-    USHORT ExpressionPosition = 0, NamePosition = 0, MatchingChars, LastDot;
+    USHORT ExpressionPosition = 0, NamePosition = 0, MatchingChars = 1;
+    BOOLEAN EndOfName = FALSE;
+    BOOLEAN Result = FALSE;
+    BOOLEAN DontSkipDot;
     WCHAR CompareChar;
     PAGED_CODE();
 
@@ -37,7 +38,7 @@
     if (!Name->Length || !Expression->Length)
     {
         /* Return TRUE if both strings are empty, otherwise FALSE */
-        if (Name->Length == 0 && Expression->Length == 0)
+        if (!Name->Length && !Expression->Length)
             return TRUE;
         else
             return FALSE;
@@ -103,193 +104,144 @@
         }
     }
 
-    while ((NamePosition < Name->Length / sizeof(WCHAR)) &&
-           (ExpressionPosition < Expression->Length / sizeof(WCHAR)))
-    {
-        /* Basic check to test if chars are equal */
-        CompareChar = IgnoreCase ? UpcaseTable[Name->Buffer[NamePosition]] :
-                                   Name->Buffer[NamePosition];
-        if (Expression->Buffer[ExpressionPosition] == CompareChar)
-        {
-            NamePosition++;
-            ExpressionPosition++;
-        }
-        /* Check cases that eat one char */
-        else if (Expression->Buffer[ExpressionPosition] == L'?')
-        {
-            NamePosition++;
-            ExpressionPosition++;
-        }
-        /* Test star */
-        else if (Expression->Buffer[ExpressionPosition] == L'*')
-        {
-            /* Skip contigous stars */
-            while ((ExpressionPosition + 1 < (USHORT)(Expression->Length /
sizeof(WCHAR))) &&
-                   (Expression->Buffer[ExpressionPosition + 1] == L'*'))
-            {
-                ExpressionPosition++;
-            }
-
-            /* Save star position */
-            StarFound++;
-            if (StarFound >= BackTrackingSize)
-            {
-                ASSERT(BackTracking == BackTrackingBuffer);
-
-                BackTrackingSize = Expression->Length / sizeof(WCHAR);
-                BackTracking = ExAllocatePoolWithTag(PagedPool |
POOL_RAISE_IF_ALLOCATION_FAILURE,
-                                                     BackTrackingSize * sizeof(USHORT),
-                                                     'nrSF');
-                RtlCopyMemory(BackTracking, BackTrackingBuffer,
sizeof(BackTrackingBuffer));
-
-            }
-            BackTracking[StarFound] = ExpressionPosition++;
-
-            /* If star is at the end, then eat all rest and leave */
-            if (ExpressionPosition == Expression->Length / sizeof(WCHAR))
-            {
-                NamePosition = Name->Length / sizeof(WCHAR);
+    /* Name parsing loop */
+    for (; !EndOfName; MatchingChars = BackTrackingPosition, NamePosition++)
+    {
+        /* Reset positions */
+        OldBackTrackingPosition = BackTrackingPosition = 0;
+
+        if (NamePosition >= Name->Length / sizeof(WCHAR))
+        {
+            EndOfName = TRUE;
+            if (OldBackTracking[MatchingChars - 1] == Expression->Length * 2)
                 break;
-            }
-
-            /* Allow null matching */
-            if (Expression->Buffer[ExpressionPosition] != L'?' &&
-                     Expression->Buffer[ExpressionPosition] !=
Name->Buffer[NamePosition])
-            {
-                NamePosition++;
-            }
-        }
-        /* Check DOS_STAR */
-        else if (Expression->Buffer[ExpressionPosition] == DOS_STAR)
-        {
-            /* Skip contigous stars */
-            while ((ExpressionPosition + 1 < (USHORT)(Expression->Length /
sizeof(WCHAR))) &&
-                   (Expression->Buffer[ExpressionPosition + 1] == DOS_STAR))
-            {
-                ExpressionPosition++;
-            }
-
-            /* Look for last dot */
-            MatchingChars = 0;
-            LastDot = (USHORT)-1;
-            while (MatchingChars < Name->Length / sizeof(WCHAR))
-            {
-                if (Name->Buffer[MatchingChars] == L'.')
-                {
-                    LastDot = MatchingChars;
-                    if (LastDot > NamePosition)
-                        break;
-                }
-
-                MatchingChars++;
-            }
-
-            /* If we don't have dots or we didn't find last yet
-             * start eating everything
-             */
-            if (MatchingChars != Name->Length || LastDot == (USHORT)-1)
-            {
-                DosStarFound++;
-                if (DosStarFound >= DosBackTrackingSize)
-                {
-                    ASSERT(DosBackTracking == DosBackTrackingBuffer);
-
-                    DosBackTrackingSize = Expression->Length / sizeof(WCHAR);
-                    DosBackTracking = ExAllocatePoolWithTag(PagedPool |
POOL_RAISE_IF_ALLOCATION_FAILURE,
-                                                            DosBackTrackingSize *
sizeof(USHORT),
+        }
+
+        while (MatchingChars > OldBackTrackingPosition)
+        {
+            ExpressionPosition = (OldBackTracking[OldBackTrackingPosition++] + 1) / 2;
+
+            /* Expression parsing loop */
+            for (Offset = 0; ExpressionPosition < Expression->Length; Offset =
sizeof(WCHAR))
+            {
+                ExpressionPosition += Offset;
+
+                if (ExpressionPosition == Expression->Length)
+                {
+                    BackTracking[BackTrackingPosition++] = Expression->Length * 2;
+                    break;
+                }
+
+                /* If buffer too small */
+                if (BackTrackingPosition > RTL_NUMBER_OF(BackTrackingBuffer) - 1)
+                {
+                    /* Allocate memory for BackTracking */
+                    BackTracking = ExAllocatePoolWithTag(PagedPool |
POOL_RAISE_IF_ALLOCATION_FAILURE,
+                                                         (Expression->Length +
sizeof(WCHAR)) * sizeof(USHORT),
+                                                         'nrSF');
+                    /* Copy old buffer content */
+                    RtlCopyMemory(BackTracking,
+                                  BackTrackingBuffer,
+                                  RTL_NUMBER_OF(BackTrackingBuffer) * sizeof(USHORT));
+
+                    /* Allocate memory for OldBackTracking */
+                    OldBackTracking = ExAllocatePoolWithTag(PagedPool |
POOL_RAISE_IF_ALLOCATION_FAILURE,
+                                                            (Expression->Length +
sizeof(WCHAR)) * sizeof(USHORT),
                                                             'nrSF');
-                    RtlCopyMemory(DosBackTracking, DosBackTrackingBuffer,
sizeof(DosBackTrackingBuffer));
-                }
-                DosBackTracking[DosStarFound] = ExpressionPosition++;
-
-                /* Not the same char, start exploring */
-                if (Expression->Buffer[ExpressionPosition] !=
Name->Buffer[NamePosition])
-                    NamePosition++;
-            }
-            else
-            {
-                /* Else, if we are at last dot, eat it - otherwise, null match */
-                if (Name->Buffer[NamePosition] == '.')
-                    NamePosition++;
-
-                 ExpressionPosition++;
-            }
-        }
-        /* Check DOS_DOT */
-        else if (Expression->Buffer[ExpressionPosition] == DOS_DOT)
-        {
-            /* We only match dots */
-            if (Name->Buffer[NamePosition] == L'.')
-            {
-                NamePosition++;
-            }
-            /* Try to explore later on for null matching */
-            else if ((ExpressionPosition + 1 < (USHORT)(Expression->Length /
sizeof(WCHAR))) &&
-                     (Name->Buffer[NamePosition] ==
Expression->Buffer[ExpressionPosition + 1]))
-            {
-                NamePosition++;
-            }
-            ExpressionPosition++;
-        }
-        /* Check DOS_QM */
-        else if (Expression->Buffer[ExpressionPosition] == DOS_QM)
-        {
-            /* We match everything except dots */
-            if (Name->Buffer[NamePosition] != L'.')
-            {
-                NamePosition++;
-            }
-            ExpressionPosition++;
-        }
-        /* If nothing match, try to backtrack */
-        else if (StarFound >= 0)
-        {
-            ExpressionPosition = BackTracking[StarFound--];
-        }
-        else if (DosStarFound >= 0)
-        {
-            ExpressionPosition = DosBackTracking[DosStarFound--];
-        }
-        /* Otherwise, fail */
-        else
-        {
-            break;
-        }
-
-        /* Under certain circumstances, expression is over, but name isn't
-         * and we can backtrack, then, backtrack */
-        if (ExpressionPosition == Expression->Length / sizeof(WCHAR) &&
-            NamePosition != Name->Length / sizeof(WCHAR) &&
-            StarFound >= 0)
-        {
-            ExpressionPosition = BackTracking[StarFound--];
-        }
-    }
-    /* If we have nullable matching wc at the end of the string, eat them */
-    if (ExpressionPosition != Expression->Length / sizeof(WCHAR) &&
NamePosition == Name->Length / sizeof(WCHAR))
-    {
-        while (ExpressionPosition < Expression->Length / sizeof(WCHAR))
-        {
-            if (Expression->Buffer[ExpressionPosition] != DOS_DOT &&
-                Expression->Buffer[ExpressionPosition] != L'*' &&
-                Expression->Buffer[ExpressionPosition] != DOS_STAR)
-            {
+                    /* Copy old buffer content */
+                    RtlCopyMemory(OldBackTracking,
+                                  OldBackTrackingBuffer,
+                                  RTL_NUMBER_OF(OldBackTrackingBuffer) *
sizeof(USHORT));
+                }
+
+                /* Basic check to test if chars are equal */
+                CompareChar = IgnoreCase ? UpcaseTable[Name->Buffer[NamePosition]] :
+                                           Name->Buffer[NamePosition];
+                if (Expression->Buffer[ExpressionPosition / sizeof(WCHAR)] ==
CompareChar && !EndOfName)
+                {
+                    BackTracking[BackTrackingPosition++] = (ExpressionPosition +
sizeof(WCHAR)) * 2;
+                }
+                /* Check cases that eat one char */
+                else if (Expression->Buffer[ExpressionPosition / sizeof(WCHAR)] ==
L'?' && !EndOfName)
+                {
+                    BackTracking[BackTrackingPosition++] = (ExpressionPosition +
sizeof(WCHAR)) * 2;
+                }
+                /* Test star */
+                else if (Expression->Buffer[ExpressionPosition / sizeof(WCHAR)] ==
L'*')
+                {
+                    BackTracking[BackTrackingPosition++] = ExpressionPosition * 2;
+                    BackTracking[BackTrackingPosition++] = (ExpressionPosition * 2) + 3;
+                    continue;
+                }
+                /* Check DOS_STAR */
+                else if (Expression->Buffer[ExpressionPosition / sizeof(WCHAR)] ==
DOS_STAR)
+                {
+                    /* Look for last dot */
+                    DontSkipDot = TRUE;
+                    if (!EndOfName && Name->Buffer[NamePosition] ==
'.')
+                    {
+                        for (Position = NamePosition - 1; Position < Name->Length;
Position++)
+                        {
+                            if (Name->Buffer[Position] == L'.')
+                            {
+                                DontSkipDot = FALSE;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (EndOfName || Name->Buffer[NamePosition] != L'.' ||
!DontSkipDot)
+                        BackTracking[BackTrackingPosition++] = ExpressionPosition * 2;
+
+                    BackTracking[BackTrackingPosition++] = (ExpressionPosition * 2) + 3;
+                    continue;
+                }
+                /* Check DOS_DOT */
+                else if (Expression->Buffer[ExpressionPosition / sizeof(WCHAR)] ==
DOS_DOT)
+                {
+                    if (EndOfName) continue;
+
+                    if (Name->Buffer[NamePosition] == L'.')
+                        BackTracking[BackTrackingPosition++] = (ExpressionPosition +
sizeof(WCHAR)) * 2;
+                }
+                /* Check DOS_QM */
+                else if (Expression->Buffer[ExpressionPosition / sizeof(WCHAR)] ==
DOS_QM)
+                {
+                    if (EndOfName || Name->Buffer[NamePosition] == L'.')
continue;
+
+                    BackTracking[BackTrackingPosition++] = (ExpressionPosition +
sizeof(WCHAR)) * 2;
+                }
+
+                /* Leave from loop */
                 break;
             }
-            ExpressionPosition++;
-        }
-    }
-
-    if (BackTracking != BackTrackingBuffer)
-    {
+
+            for (Position = 0; MatchingChars > OldBackTrackingPosition &&
Position < BackTrackingPosition; Position++)
+            {
+                while (MatchingChars > OldBackTrackingPosition &&
+                       BackTracking[Position] >
OldBackTracking[OldBackTrackingPosition])
+                {
+                    ++OldBackTrackingPosition;
+                }
+            }
+        }
+
+        /* Swap pointers */
+        BackTrackingSwap = BackTracking;
+        BackTracking = OldBackTracking;
+        OldBackTracking = BackTrackingSwap;
+    }
+
+    /* Store result value */
+    Result = (OldBackTracking[MatchingChars - 1] == (Expression->Length * 2));
+
+    /* Frees the memory if necessary */
+    if (BackTracking != BackTrackingBuffer && BackTracking !=
OldBackTrackingBuffer)
         ExFreePoolWithTag(BackTracking, 'nrSF');
-    }
-    if (DosBackTracking != DosBackTrackingBuffer)
-    {
-        ExFreePoolWithTag(DosBackTracking, 'nrSF');
-    }
-
-    return (ExpressionPosition == Expression->Length / sizeof(WCHAR) &&
NamePosition == Name->Length / sizeof(WCHAR));
+    if (OldBackTracking != BackTrackingBuffer && OldBackTracking !=
OldBackTrackingBuffer)
+        ExFreePoolWithTag(OldBackTracking, 'nrSF');
+
+    return Result;
 }
 
 /* PUBLIC FUNCTIONS **********************************************************/