dbcsname.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for dbcsname.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID NTAPI	FsRtlDissectDbcs (IN ANSI_STRING Name, OUT PANSI_STRING FirstPart, OUT PANSI_STRING RemainingPart)
BOOLEAN NTAPI	FsRtlDoesDbcsContainWildCards (IN PANSI_STRING Name)
BOOLEAN NTAPI	FsRtlIsDbcsInExpression (IN PANSI_STRING Expression, IN PANSI_STRING Name)
BOOLEAN NTAPI	FsRtlIsFatDbcsLegal (IN ANSI_STRING DbcsName, IN BOOLEAN WildCardsPermissible, IN BOOLEAN PathNamePermissible, IN BOOLEAN LeadingBackslashPermissible)
BOOLEAN NTAPI	FsRtlIsHpfsDbcsLegal (IN ANSI_STRING DbcsName, IN BOOLEAN WildCardsPermissible, IN BOOLEAN PathNamePermissible, IN BOOLEAN LeadingBackslashPermissible)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file dbcsname.c.

Function Documentation

FsRtlDissectDbcs()

VOID NTAPI FsRtlDissectDbcs	(	IN ANSI_STRING	Name,
		OUT PANSI_STRING	FirstPart,
		OUT PANSI_STRING	RemainingPart
	)

Definition at line 45 of file dbcsname.c.

{
    USHORT FirstPosition, i;
    USHORT SkipFirstSlash = 0;
    PAGED_CODE();

    /* Zero the strings before continuing */
    RtlZeroMemory(FirstPart, sizeof(ANSI_STRING));
    RtlZeroMemory(RemainingPart, sizeof(ANSI_STRING));

    /* Just quit if the string is empty */
    if (!Name.Length) return;

    /* Find first backslash */
    FirstPosition = Name.Length;
    for (i = 0; i < Name.Length; i++)
    {
        /* First make sure the character it's not the Lead DBCS */
        if (FsRtlIsLeadDbcsCharacter(Name.Buffer[i]))
        {
            i++;
        }
        /* If we found one... */
        else if (Name.Buffer[i] == '\\')
        {
            /* If it begins string, just notice it and continue */
            if (i == 0)
            {
                SkipFirstSlash = 1;
            }
            else
            {
                /* Else, save its position and break out of the loop */
                FirstPosition = i;
                break;
            }
        }
    }

    /* Set up the first result string */
    FirstPart->Buffer = Name.Buffer + SkipFirstSlash;
    FirstPart->Length = (FirstPosition - SkipFirstSlash);
    FirstPart->MaximumLength = FirstPart->Length;

    /* And second one, if necessary */
    if (FirstPosition < (Name.Length))
    {
        RemainingPart->Buffer = Name.Buffer + FirstPosition + 1;
        RemainingPart->Length = Name.Length - (FirstPosition + 1);
        RemainingPart->MaximumLength = RemainingPart->Length;
    }
}

Referenced by FsRtlIsFatDbcsLegal(), FsRtlIsHpfsDbcsLegal(), and START_TEST().

FsRtlDoesDbcsContainWildCards()

BOOLEAN NTAPI FsRtlDoesDbcsContainWildCards

(

IN PANSI_STRING

Name

)

Definition at line 117 of file dbcsname.c.

{
    USHORT i;
    PAGED_CODE();

    /* Check every character */
    for (i = 0; i < Name->Length; i++)
    {
        /* First make sure it's not the Lead DBCS */
        if (FsRtlIsLeadDbcsCharacter(Name->Buffer[i]))
        {
            i++;
        }
        else if (FsRtlIsAnsiCharacterWild(Name->Buffer[i]))
        {
            /* Now return if it has a wildcard */
            return TRUE;
        }
    }

    /* We didn't return above...so none found */
    return FALSE;
}

Referenced by FsRtlIsDbcsInExpression(), and FsRtlIsFatDbcsLegal().

FsRtlIsDbcsInExpression()

BOOLEAN NTAPI FsRtlIsDbcsInExpression	(	IN PANSI_STRING	Expression,
		IN PANSI_STRING	Name
	)

Definition at line 160 of file dbcsname.c.

{
    USHORT Offset, Position, BackTrackingPosition, OldBackTrackingPosition;
    USHORT BackTrackingBuffer[16], OldBackTrackingBuffer[16] = {0};
    PUSHORT BackTrackingSwap, BackTracking = BackTrackingBuffer, OldBackTracking = OldBackTrackingBuffer;
    ULONG BackTrackingBufferSize = RTL_NUMBER_OF(BackTrackingBuffer);
    PVOID AllocatedBuffer = NULL;
    USHORT ExpressionPosition, NamePosition = 0, MatchingChars = 1;
    USHORT NameChar = 0, ExpressionChar;
    BOOLEAN EndOfName = FALSE;
    BOOLEAN Result;
    BOOLEAN DontSkipDot;
    PAGED_CODE();

    ASSERT(Name->Length);
    ASSERT(Expression->Length);
    ASSERT(!FsRtlDoesDbcsContainWildCards(Name));

    /* Check if we were given strings at all */
    if (!Name->Length || !Expression->Length)
    {
        /* Return TRUE if both strings are empty, otherwise FALSE */
        if (Name->Length == 0 && Expression->Length == 0)
            return TRUE;
        else
            return FALSE;
    }

    /* Check for a shortcut: just one wildcard */
    if (Expression->Length == sizeof(CHAR))
    {
        if (Expression->Buffer[0] == '*')
            return TRUE;
    }

    //ASSERT(FsRtlDoesDbcsContainWildCards(Expression));

    /* Another shortcut, wildcard followed by some string */
    if (Expression->Buffer[0] == '*')
    {
        /* Copy Expression to our local variable */
        ANSI_STRING IntExpression = *Expression;

        /* Skip the first char */
        IntExpression.Buffer++;
        IntExpression.Length -= sizeof(CHAR);

        /* Continue only if the rest of the expression does NOT contain
           any more wildcards */
        if (!FsRtlDoesDbcsContainWildCards(&IntExpression))
        {
            /* Check for a degenerate case */
            if (Name->Length < (Expression->Length - sizeof(CHAR)))
                return FALSE;

            /* Calculate position */
            NamePosition = (Name->Length - IntExpression.Length) / sizeof(CHAR);

            /* Check whether we are breaking a two chars char (DBCS) */
            if (NlsMbOemCodePageTag)
            {
                MatchingChars = 0;

                while (MatchingChars < NamePosition)
                {
                    /* Check if current char is DBCS lead char, if so, jump by two chars */
                    MatchingChars += FsRtlIsLeadDbcsCharacter(Name->Buffer[MatchingChars]) ? 2 : 1;
                }

                /* If so, deny */
                if (MatchingChars > NamePosition)
                    return FALSE;
            }

            /* Compare */
            return RtlEqualMemory(IntExpression.Buffer,
                                  (Name->Buffer + NamePosition),
                                  IntExpression.Length);
        }
    }

    /* Name parsing loop */
    for (; !EndOfName; MatchingChars = BackTrackingPosition)
    {
        /* Reset positions */
        OldBackTrackingPosition = BackTrackingPosition = 0;

        if (NamePosition >= Name->Length)
        {
            EndOfName = TRUE;
            if (MatchingChars && OldBackTracking[MatchingChars - 1] == Expression->Length * 2)
                break;
        }
        else
        {
            /* If lead byte present */
            if (FsRtlIsLeadDbcsCharacter(Name->Buffer[NamePosition]))
            {
                NameChar = Name->Buffer[NamePosition] +
                           (0x100 * Name->Buffer[NamePosition + 1]);
                NamePosition += sizeof(USHORT);
            }
            else
            {
                NameChar = Name->Buffer[NamePosition];
                NamePosition += sizeof(UCHAR);
            }
        }

        while (MatchingChars > OldBackTrackingPosition)
        {
            ExpressionPosition = (OldBackTracking[OldBackTrackingPosition++] + 1) / 2;

            /* Expression parsing loop */
            for (Offset = 0; ExpressionPosition < Expression->Length; )
            {
                ExpressionPosition += Offset;

                if (ExpressionPosition == Expression->Length)
                {
                    BackTracking[BackTrackingPosition++] = Expression->Length * 2;
                    break;
                }

                /* If buffer too small */
                if (BackTrackingPosition > BackTrackingBufferSize - 3)
                {
                    /* We should only ever get here once! */
                    ASSERT(AllocatedBuffer == NULL);
                    ASSERT((BackTracking == BackTrackingBuffer) || (BackTracking == OldBackTrackingBuffer));
                    ASSERT((OldBackTracking == BackTrackingBuffer) || (OldBackTracking == OldBackTrackingBuffer));

                    /* Calculate buffer size */
                    BackTrackingBufferSize = Expression->Length * 2 + 1;

                    /* Allocate memory for both back-tracking buffers */
                    AllocatedBuffer = ExAllocatePoolWithTag(PagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE,
                                                            2 * BackTrackingBufferSize * sizeof(USHORT),
                                                            'nrSF');
                    if (AllocatedBuffer == NULL)
                    {
                        DPRINT1("Failed to allocate BackTracking buffer. BackTrackingBufferSize = =x%lx\n",
                                BackTrackingBufferSize);
                        Result = FALSE;
                        goto Exit;
                    }

                    /* Copy BackTracking content. Note that it can point to either BackTrackingBuffer or OldBackTrackingBuffer */
                    RtlCopyMemory(AllocatedBuffer,
                                  BackTracking,
                                  RTL_NUMBER_OF(BackTrackingBuffer) * sizeof(USHORT));

                    /* Place current Backtracking is at the start of the new buffer */
                    BackTracking = AllocatedBuffer;

                    /* Copy OldBackTracking content */
                    RtlCopyMemory(&BackTracking[BackTrackingBufferSize],
                                  OldBackTracking,
                                  RTL_NUMBER_OF(OldBackTrackingBuffer) * sizeof(USHORT));

                    /* Place current OldBackTracking after current BackTracking in the buffer */
                    OldBackTracking = &BackTracking[BackTrackingBufferSize];
                }

                /* If lead byte present */
                if (FsRtlIsLeadDbcsCharacter(Expression->Buffer[ExpressionPosition]))
                {
                    ExpressionChar = Expression->Buffer[ExpressionPosition] +
                                     (0x100 * Expression->Buffer[ExpressionPosition + 1]);
                    Offset = sizeof(USHORT);
                }
                else
                {
                    ExpressionChar = Expression->Buffer[ExpressionPosition];
                    Offset = sizeof(UCHAR);
                }

                /* Basic check to test if chars are equal */
                if (ExpressionChar == NameChar && !EndOfName)
                {
                    BackTracking[BackTrackingPosition++] = (ExpressionPosition + Offset) * 2;
                }
                /* Check cases that eat one char */
                else if (ExpressionChar == '?' && !EndOfName)
                {
                    BackTracking[BackTrackingPosition++] = (ExpressionPosition + Offset) * 2;
                }
                /* Test star */
                else if (ExpressionChar == '*')
                {
                    BackTracking[BackTrackingPosition++] = ExpressionPosition * 2;
                    BackTracking[BackTrackingPosition++] = (ExpressionPosition * 2) + 1;
                    continue;
                }
                /* Check DOS_STAR */
                else if (ExpressionChar == ANSI_DOS_STAR)
                {
                    /* Look for last dot */
                    DontSkipDot = TRUE;
                    if (!EndOfName && NameChar == '.')
                    {
                        for (Position = NamePosition; Position < Name->Length; )
                        {
                            /* If lead byte not present */
                            if (!FsRtlIsLeadDbcsCharacter(Name->Buffer[Position]))
                            {
                                if (Name->Buffer[Position] == '.')
                                {
                                    DontSkipDot = FALSE;
                                    break;
                                }

                                Position += sizeof(UCHAR);
                            }
                            else
                            {
                                Position += sizeof(USHORT);
                            }
                        }
                    }

                    if (EndOfName || NameChar != '.' || !DontSkipDot)
                        BackTracking[BackTrackingPosition++] = ExpressionPosition * 2;

                    BackTracking[BackTrackingPosition++] = (ExpressionPosition * 2) + 1;
                    continue;
                }
                /* Check DOS_DOT */
                else if (ExpressionChar == ANSI_DOS_DOT)
                {
                    if (EndOfName) continue;

                    if (NameChar == '.')
                        BackTracking[BackTrackingPosition++] = (ExpressionPosition + Offset) * 2;
                }
                /* Check DOS_QM */
                else if (ExpressionChar == ANSI_DOS_QM)
                {
                    if (EndOfName || NameChar == '.') continue;

                    BackTracking[BackTrackingPosition++] = (ExpressionPosition + Offset) * 2;
                }

                /* Leave from loop */
                break;
            }

            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 = MatchingChars && (OldBackTracking[MatchingChars - 1] == Expression->Length * 2);

Exit:

    /* Frees the memory if necessary */
    if (AllocatedBuffer != NULL)
    {
        ExFreePoolWithTag(AllocatedBuffer, 'nrSF');
    }

    return Result;
}

Referenced by FatIsNameInExpression(), and FsRtlIsDbcsInExpressionTest().

FsRtlIsFatDbcsLegal()

BOOLEAN NTAPI FsRtlIsFatDbcsLegal	(	IN ANSI_STRING	DbcsName,
		IN BOOLEAN	WildCardsPermissible,
		IN BOOLEAN	PathNamePermissible,
		IN BOOLEAN	LeadingBackslashPermissible
	)

Definition at line 466 of file dbcsname.c.

{
    ANSI_STRING FirstPart, RemainingPart;
    BOOLEAN LastDot;
    USHORT i;
    PAGED_CODE();

    /* Just quit if the string is empty */
    if (!DbcsName.Length)
        return FALSE;

    /* Accept special filename if wildcards are allowed */
    if (WildCardsPermissible && (DbcsName.Length == 1 || DbcsName.Length == 2) && DbcsName.Buffer[0] == '.')
    {
        if (DbcsName.Length == 2)
        {
            if (DbcsName.Buffer[1] == '.')
                return TRUE;
        }
        else
        {
            return TRUE;
        }
    }

    /* DbcsName wasn't supposed to be started with \ */
    if (!LeadingBackslashPermissible && DbcsName.Buffer[0] == '\\')
        return FALSE;
    /* DbcsName was allowed to be started with \, but now, remove it */
    else if (LeadingBackslashPermissible && DbcsName.Buffer[0] == '\\')
    {
        DbcsName.Buffer = DbcsName.Buffer + 1;
        DbcsName.Length = DbcsName.Length - 1;
        DbcsName.MaximumLength = DbcsName.MaximumLength - 1;
    }

    if (PathNamePermissible)
    {
        /* We copy the buffer for FsRtlDissectDbcs call */
        RemainingPart.Buffer = DbcsName.Buffer;
        RemainingPart.Length = DbcsName.Length;
        RemainingPart.MaximumLength = DbcsName.MaximumLength;

        while (RemainingPart.Length > 0)
        {
            if (RemainingPart.Buffer[0] == '\\')
                return FALSE;

            /* Call once again our dissect function */
            FsRtlDissectDbcs(RemainingPart, &FirstPart, &RemainingPart);

            if (!FsRtlIsFatDbcsLegal(FirstPart,
                                     WildCardsPermissible,
                                     FALSE,
                                     FALSE))
            {
                return FALSE;
            }
        }

        return TRUE;
    }

    if (WildCardsPermissible && FsRtlDoesDbcsContainWildCards(&DbcsName))
    {
        for (i = 0; i < DbcsName.Length; i++)
        {
            /* First make sure the character it's not the Lead DBCS */
            if (FsRtlIsLeadDbcsCharacter(DbcsName.Buffer[i]))
            {
                i++;
            }
            /* Then check for bad characters */
            else if (!FsRtlIsAnsiCharacterLegalFat(DbcsName.Buffer[i], TRUE))
            {
                return FALSE;
            }
        }

        return TRUE;
    }

    /* Filename must be 8.3 filename */
    if (DbcsName.Length > 12)
        return FALSE;

    /* Reset dots count */
    LastDot = FALSE;

    for (i = 0; i < DbcsName.Length; i++)
    {
        /* First make sure the character it's not the Lead DBCS */
        if (FsRtlIsLeadDbcsCharacter(DbcsName.Buffer[i]))
        {
            if (!LastDot && (i >= 7))
                return FALSE;

            if (i == (DbcsName.Length - 1))
                return FALSE;

            i++;
            continue;
        }
        /* Then check for bad characters */
        else if (!FsRtlIsAnsiCharacterLegalFat(DbcsName.Buffer[i], WildCardsPermissible))
        {
            return FALSE;
        }
        else if (DbcsName.Buffer[i] == '.')
        {
            /* Filename can only contain one dot */
            if (LastDot)
                return FALSE;

            LastDot = TRUE;

            /* We mustn't have spaces before dot or at the end of the filename
             * and no dot at the beginning of the filename */
            if (i == (DbcsName.Length - 1) || i == 0)
                return FALSE;

            /* Filename must be 8.3 filename and not 3.8 filename */
            if ((DbcsName.Length - 1) - i > 3)
                return FALSE;

            if ((i > 0) && DbcsName.Buffer[i - 1] == ' ')
                return FALSE;
        }
        /* Filename mustn't finish with a space */
        else if (DbcsName.Buffer[i] == ' ' && i == (DbcsName.Length - 1))
        {
            return FALSE;
        }

        if (!LastDot && (i >= 8))
            return FALSE;
    }

    return TRUE;
}

Referenced by CdIs8dot3Name(), and START_TEST().

FsRtlIsHpfsDbcsLegal()

BOOLEAN NTAPI FsRtlIsHpfsDbcsLegal	(	IN ANSI_STRING	DbcsName,
		IN BOOLEAN	WildCardsPermissible,
		IN BOOLEAN	PathNamePermissible,
		IN BOOLEAN	LeadingBackslashPermissible
	)

Definition at line 638 of file dbcsname.c.

{
    ANSI_STRING FirstPart, RemainingPart;
    USHORT i;
    PAGED_CODE();

    /* Just quit if the string is empty */
    if (!DbcsName.Length)
        return FALSE;

    /* Accept special filename if wildcards are allowed */
    if (WildCardsPermissible && (DbcsName.Length == 1 || DbcsName.Length == 2) && DbcsName.Buffer[0] == '.')
    {
        if (DbcsName.Length == 2)
        {
            if (DbcsName.Buffer[1] == '.')
                return TRUE;
        }
        else
        {
            return TRUE;
        }
    }

    /* DbcsName wasn't supposed to be started with \ */
    if (!LeadingBackslashPermissible && DbcsName.Buffer[0] == '\\')
        return FALSE;
    /* DbcsName was allowed to be started with \, but now, remove it */
    else if (LeadingBackslashPermissible && DbcsName.Buffer[0] == '\\')
    {
        DbcsName.Buffer = DbcsName.Buffer + 1;
        DbcsName.Length = DbcsName.Length - 1;
        DbcsName.MaximumLength = DbcsName.MaximumLength - 1;
    }

    if (PathNamePermissible)
    {
        /* We copy the buffer for FsRtlDissectDbcs call */
        RemainingPart.Buffer = DbcsName.Buffer;
        RemainingPart.Length = DbcsName.Length;
        RemainingPart.MaximumLength = DbcsName.MaximumLength;

        while (RemainingPart.Length > 0)
        {
            if (RemainingPart.Buffer[0] == '\\')
                return FALSE;

            /* Call once again our dissect function */
            FsRtlDissectDbcs(RemainingPart, &FirstPart, &RemainingPart);

            if (!FsRtlIsHpfsDbcsLegal(FirstPart,
                                      WildCardsPermissible,
                                      FALSE,
                                      FALSE))
            {
                return FALSE;
            }
        }

        return TRUE;
    }

    if (DbcsName.Length > 255)
        return FALSE;

    for (i = 0; i < DbcsName.Length; i++)
    {
        /* First make sure the character it's not the Lead DBCS */
        if (FsRtlIsLeadDbcsCharacter(DbcsName.Buffer[i]))
        {
            if (i == (DbcsName.Length - 1))
                return FALSE;
            i++;
        }
        /* Then check for bad characters */
        else if (!FsRtlIsAnsiCharacterLegalHpfs(DbcsName.Buffer[i], WildCardsPermissible))
        {
            return FALSE;
        }
        /* Filename mustn't finish with a space or a dot */
        else if ((DbcsName.Buffer[i] == ' ' || DbcsName.Buffer[i] == '.') && i == (DbcsName.Length - 1))
        {
            return FALSE;
        }
    }

    return TRUE;
}

Referenced by START_TEST().