name.c File Reference

#include <rtl.h>
#include <debug.h>

Include dependency graph for name.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	DOS_STAR   (L'<')
#define	DOS_QM   (L'>')
#define	DOS_DOT   (L'"')
#define	EXPRESSION_IS_WILDCARD(expr, len)
#define	IS_LITERAL_OR_DOS_DOT(wchar)    (wchar == DOS_DOT || (wchar != L'*' && wchar != DOS_STAR && wchar != L'?' && wchar != DOS_QM))

Functions
static __inline BOOLEAN	RtlpContainsWildcard (_In_ PWCH Buffer, _In_ ULONG Length)
static __inline WCHAR	RtlpGetExprChar (_In_ PWCH Buffer, _In_ ULONG Position, _In_ ULONG Length, _In_ BOOLEAN IgnoreCase, _In_opt_ PWCH UpcaseTable)
BOOLEAN NTAPI	RtlIsNameInExpression (_In_ PUNICODE_STRING Expression, _In_ PUNICODE_STRING Name, _In_ BOOLEAN IgnoreCase, _In_opt_ PWCH UpcaseTable)

Macro Definition Documentation

DOS_DOT

#define DOS_DOT   (L'"')

Definition at line 14 of file name.c.

DOS_QM

#define DOS_QM   (L'>')

Definition at line 13 of file name.c.

DOS_STAR

#define DOS_STAR   (L'<')

Definition at line 12 of file name.c.

EXPRESSION_IS_WILDCARD

#define EXPRESSION_IS_WILDCARD	(		expr,
			len
	)

Value:

    (len == 1 && expr->Buffer[0] == L'*') \
    || (len == 3 && expr->Buffer[0] == L'*' && expr->Buffer[1] == L'.' && expr->Buffer[2] == L'*')

Definition at line 16 of file name.c.

IS_LITERAL_OR_DOS_DOT

#define IS_LITERAL_OR_DOS_DOT

(

wchar

)

(wchar == DOS_DOT || (wchar != L'*' && wchar != DOS_STAR && wchar != L'?' && wchar != DOS_QM))

Definition at line 19 of file name.c.

NDEBUG

#define NDEBUG

Definition at line 9 of file name.c.

Function Documentation

RtlIsNameInExpression()

BOOLEAN NTAPI RtlIsNameInExpression	(	_In_ PUNICODE_STRING	Expression,
		_In_ PUNICODE_STRING	Name,
		_In_ BOOLEAN	IgnoreCase,
		_In_opt_ PWCH	UpcaseTable
	)

Definition at line 56 of file name.c.

{
    ULONG NameLen = Name->Length / sizeof(WCHAR);
    ULONG ExprLen = Expression->Length / sizeof(WCHAR);
    ULONG NamePos = 0, ExprPos = 0;
    ULONG StarExprPos = MAXULONG;
    ULONG StarNamePos = 0;
 
    /* For more information about this algorithm, see
     * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fsa/0b034646-4e23-4874-8488-2adac231ff23
     */
 
    /* *** Optimizations *** */
 
    /* Empty string */
    if (ExprLen == 0 || NameLen == 0)
        return (ExprLen == 0 && NameLen == 0);
 
    /* Wildcard only */
    if (EXPRESSION_IS_WILDCARD(Expression, ExprLen))
        return TRUE;
 
    /* Wildcard + literal with no other wildcards */
    if (ExprLen >= 2
        && NameLen >= ExprLen - 1
        && Expression->Buffer[0] == L'*'
        && !RtlpContainsWildcard(&Expression->Buffer[1], ExprLen - 1))
    {
        ExprPos = 1;
        NamePos = NameLen - (ExprLen - 1);
 
        while (ExprPos < ExprLen)
        {
            WCHAR NameChar = RtlpGetExprChar(Name->Buffer, NamePos, NameLen, IgnoreCase, UpcaseTable);
            WCHAR ExprChar = RtlpGetExprChar(Expression->Buffer, ExprPos, ExprLen, IgnoreCase, UpcaseTable);
            if (ExprChar != NameChar)
                return FALSE;
            NamePos++;
            ExprPos++;
        }
 
        return TRUE;
    }
 
    /* *** Main parser *** */
 
    for (;;)
    {
        /* We passed everything and reached the end of both the name and expression. */
        if (NamePos >= NameLen && ExprPos >= ExprLen)
            return TRUE;
 
        WCHAR NameChar = RtlpGetExprChar(Name->Buffer, NamePos, NameLen, IgnoreCase, UpcaseTable);
        WCHAR ExprChar = RtlpGetExprChar(Expression->Buffer, ExprPos, ExprLen, IgnoreCase, UpcaseTable);
 
        /* '?' or character literal */
        if ((ExprChar == L'?' && NamePos < NameLen)
            || (IS_LITERAL_OR_DOS_DOT(ExprChar) && ExprChar == NameChar))
        {
            NamePos++;
            ExprPos++;
            continue;
        }
 
        /* '*' */
        if (ExprChar == L'*')
        {
            StarExprPos = ExprPos;
            StarNamePos = NamePos;
            ExprPos++;
            continue;
        }
 
        /* DOS_STAR */
        if (ExprChar == DOS_STAR)
        {
            ULONG LookPos = ExprPos + 1;
            StarExprPos = ExprPos;
            StarNamePos = NamePos;
 
            while (LookPos < ExprLen)
            {
                WCHAR LookChar = Expression->Buffer[LookPos];
                if (IS_LITERAL_OR_DOS_DOT(LookChar))
                    break;
                LookPos++;
            }
 
            ExprPos++;
            continue;
        }
 
        /* DOS_QM */
        if (ExprChar == DOS_QM)
        {
            if (NamePos >= NameLen || NameChar == L'.')
            {
                /* Dot or end-of-name: skip all consecutive DOS_QM tokens */
                while (ExprPos < ExprLen && Expression->Buffer[ExprPos] == DOS_QM)
                    ExprPos++;
                continue;
            }
 
            /* Normal DOS_QM: consume one non-dot character */
            NamePos++;
            ExprPos++;
            continue;
        }
 
        /* DOS_DOT */
        if (ExprChar == DOS_DOT)
        {
            if (NamePos >= NameLen)
            {
                ExprPos++;
                continue;
            }
 
            if (NameChar == L'.')
            {
                NamePos++;
                ExprPos++;
                continue;
            }
        }
 
        /* Backtrack from a '*' or DOS_STAR */
        if (StarExprPos != MAXULONG)
        {
            /* A DOS_STAR at the end cannot consume a trailing '.' in the name */
            if (Expression->Buffer[StarExprPos] == DOS_STAR && ExprPos >= ExprLen)
            {
                ULONG i;
                for (i = StarNamePos; i < NameLen; i++)
                {
                    if (Name->Buffer[i] == L'.')
                        return FALSE;
                }
            }
 
            if (StarNamePos < NameLen)
            {
                StarNamePos++;
                NamePos = StarNamePos;
                ExprPos = StarExprPos + 1;
                continue;
            }
        }
 
        return FALSE;
    }
}

RtlpContainsWildcard()

static __inline BOOLEAN RtlpContainsWildcard ( _In_ PWCH  Buffer, _In_ ULONG  Length  )

static

Definition at line 25 of file name.c.

{
    for (ULONG i = 0; i < Length; i++)
    {
        WCHAR c = Buffer[i];
        if (c == L'*' || c == L'?' || c == DOS_STAR || c == DOS_QM || c == DOS_DOT)
            return TRUE;
    }
    return FALSE;
}

RtlpGetExprChar()

static __inline WCHAR RtlpGetExprChar ( _In_ PWCH  Buffer, _In_ ULONG  Position, _In_ ULONG  Length, _In_ BOOLEAN  IgnoreCase, _In_opt_ PWCH  UpcaseTable  )

static

Definition at line 39 of file name.c.

{
    WCHAR Result = (Position < Length) ? Buffer[Position] : L'\0';
    if (IgnoreCase)
        Result = UpcaseTable ? UpcaseTable[Result] : RtlUpcaseUnicodeChar(Result);
    return Result;
}