reactos/sdk/lib/rtl/path.c

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS system libraries
 * FILE:            lib/rtl/path.c
 * PURPOSE:         Path and current directory functions
 * PROGRAMMERS:     Wine team
 *                  Thomas Weidenmueller
 *                  Gunnar Dalsnes
 *                  Alex Ionescu (alex.ionescu@reactos.org)
 *                  Pierre Schweitzer (pierre@reactos.org)
 */

/* INCLUDES *******************************************************************/

#include <rtl.h>

#define NDEBUG
#include <debug.h>

/* DEFINITONS and MACROS ******************************************************/

#define MAX_PFX_SIZE       16

#define IS_PATH_SEPARATOR(x) (((x)==L'\\')||((x)==L'/'))

#define RTL_CURDIR_IS_REMOVABLE 0x1
#define RTL_CURDIR_DROP_OLD_HANDLE 0x2
#define RTL_CURDIR_ALL_FLAGS (RTL_CURDIR_DROP_OLD_HANDLE | RTL_CURDIR_IS_REMOVABLE) // 0x3
C_ASSERT(RTL_CURDIR_ALL_FLAGS == OBJ_HANDLE_TAGBITS);


/* GLOBALS ********************************************************************/

const UNICODE_STRING DeviceRootString = RTL_CONSTANT_STRING(L"\\\\.\\");

const UNICODE_STRING RtlpDosDevicesUncPrefix = RTL_CONSTANT_STRING(L"\\??\\UNC\\");
const UNICODE_STRING RtlpWin32NtRootSlash    = RTL_CONSTANT_STRING(L"\\\\?\\");
const UNICODE_STRING RtlpDosSlashCONDevice   = RTL_CONSTANT_STRING(L"\\\\.\\CON");
const UNICODE_STRING RtlpDosDevicesPrefix    = RTL_CONSTANT_STRING(L"\\??\\");

const UNICODE_STRING RtlpDosLPTDevice = RTL_CONSTANT_STRING(L"LPT");
const UNICODE_STRING RtlpDosCOMDevice = RTL_CONSTANT_STRING(L"COM");
const UNICODE_STRING RtlpDosPRNDevice = RTL_CONSTANT_STRING(L"PRN");
const UNICODE_STRING RtlpDosAUXDevice = RTL_CONSTANT_STRING(L"AUX");
const UNICODE_STRING RtlpDosCONDevice = RTL_CONSTANT_STRING(L"CON");
const UNICODE_STRING RtlpDosNULDevice = RTL_CONSTANT_STRING(L"NUL");

const UNICODE_STRING RtlpDoubleSlashPrefix   = RTL_CONSTANT_STRING(L"\\\\");

static const UNICODE_STRING RtlpDefaultExtension = RTL_CONSTANT_STRING(L".DLL");
static const UNICODE_STRING RtlpDotLocal = RTL_CONSTANT_STRING(L".Local\\");
static const UNICODE_STRING RtlpPathDividers = RTL_CONSTANT_STRING(L"\\/");


PRTLP_CURDIR_REF RtlpCurDirRef;

/* PRIVATE FUNCTIONS **********************************************************/

RTL_PATH_TYPE
NTAPI
RtlDetermineDosPathNameType_Ustr(IN PCUNICODE_STRING PathString)
{
    PWCHAR Path;
    ULONG Chars;

    Path = PathString->Buffer;
    Chars = PathString->Length / sizeof(WCHAR);

    /* Return if there are no characters */
    if (!Chars) return RtlPathTypeRelative;

    /*
     * The algorithm is similar to RtlDetermineDosPathNameType_U but here we
     * actually check for the path length before touching the characters
     */
    if (IS_PATH_SEPARATOR(Path[0]))
    {
        if ((Chars < 2) || !(IS_PATH_SEPARATOR(Path[1]))) return RtlPathTypeRooted;                /* \x             */
        if ((Chars < 3) || ((Path[2] != L'.') && (Path[2] != L'?'))) return RtlPathTypeUncAbsolute;/* \\x            */
        if ((Chars >= 4) && (IS_PATH_SEPARATOR(Path[3]))) return RtlPathTypeLocalDevice;           /* \\.\x or \\?\x */
        if (Chars != 3) return RtlPathTypeUncAbsolute;                                             /* \\.x or \\?x   */
        return RtlPathTypeRootLocalDevice;                                                         /* \\. or \\?     */
    }
    else
    {
        if ((Chars < 2) || (Path[1] != L':')) return RtlPathTypeRelative;                          /* x              */
        if ((Chars < 3) || !(IS_PATH_SEPARATOR(Path[2]))) return RtlPathTypeDriveRelative;         /* x:             */
        return RtlPathTypeDriveAbsolute;                                                           /* x:\            */
    }
}

ULONG
NTAPI
RtlIsDosDeviceName_Ustr(IN PCUNICODE_STRING PathString)
{
    UNICODE_STRING PathCopy;
    PWCHAR Start, End;
    USHORT PathChars, ColonCount = 0;
    USHORT ReturnOffset = 0, ReturnLength, OriginalLength;
    WCHAR c;

    /* Validate the input */
    if (!PathString) return 0;

    /* Check what type of path this is */
    switch (RtlDetermineDosPathNameType_Ustr(PathString))
    {
        /* Fail for UNC or unknown paths */
        case RtlPathTypeUnknown:
        case RtlPathTypeUncAbsolute:
            return 0;

        /* Make special check for the CON device */
        case RtlPathTypeLocalDevice:
            if (RtlEqualUnicodeString(PathString, &RtlpDosSlashCONDevice, TRUE))
            {
                /* This should return 0x80006 */
                return MAKELONG(RtlpDosCONDevice.Length, DeviceRootString.Length);
            }
            return 0;

        default:
            break;
    }

    /* Make a copy of the string */
    PathCopy = *PathString;
    OriginalLength = PathString->Length;

    /* Return if there's no characters */
    PathChars = PathCopy.Length / sizeof(WCHAR);
    if (!PathChars) return 0;

    /* Check for drive path and truncate */
    if (PathCopy.Buffer[PathChars - 1] == L':')
    {
        /* Fixup the lengths */
        PathCopy.Length -= sizeof(WCHAR);
        if (!--PathChars) return 0;

        /* Remember this for later */
        ColonCount = 1;
    }

    /* Check for extension or space, and truncate */
    do
    {
        /* Stop if we hit something else than a space or period */
        c = PathCopy.Buffer[PathChars - 1];
        if ((c != L'.') && (c != L' ')) break;

        /* Fixup the lengths */
        PathCopy.Length -= sizeof(WCHAR);

        /* Remember this for later */
        ColonCount++;
    } while (--PathChars);

    /* Anything still left? */
    if (PathChars)
    {
        /* Loop from the end */
        for (End = &PathCopy.Buffer[PathChars - 1];
             End >= PathCopy.Buffer;
             --End)
        {
            /* Check if the character is a path or drive separator */
            c = *End;
            if (IS_PATH_SEPARATOR(c) || ((c == L':') && (End == PathCopy.Buffer + 1)))
            {
                /* Get the next lower case character */
                End++;
                c = RtlpDowncaseUnicodeChar(*End);

                /* Check if it's a DOS device (LPT, COM, PRN, AUX, or NUL) */
                if ((End < &PathCopy.Buffer[OriginalLength / sizeof(WCHAR)]) &&
                    ((c == L'l') || (c == L'c') || (c == L'p') || (c == L'a') || (c == L'n')))
                {
                    /* Calculate the offset */
                    ReturnOffset = (USHORT)((PCHAR)End - (PCHAR)PathCopy.Buffer);

                    /* Build the final string */
                    PathCopy.Length = OriginalLength - ReturnOffset - (ColonCount * sizeof(WCHAR));
                    PathCopy.Buffer = End;

                    /* Save new amount of chars in the path */
                    PathChars = PathCopy.Length / sizeof(WCHAR);

                    break;
                }
                else
                {
                    return 0;
                }
            }
        }

        /* Get the next lower case character and check if it's a DOS device */
        c = RtlpDowncaseUnicodeChar(*PathCopy.Buffer);
        if ((c != L'l') && (c != L'c') && (c != L'p') && (c != L'a') && (c != L'n'))
        {
            /* Not LPT, COM, PRN, AUX, or NUL */
            return 0;
        }
    }

    /* Now skip past any extra extension or drive letter characters */
    Start = PathCopy.Buffer;
    End = &Start[PathChars];
    while (Start < End)
    {
        c = *Start;
        if ((c == L'.') || (c == L':')) break;
        Start++;
    }

    /* And then go backwards to get rid of spaces */
    while ((Start > PathCopy.Buffer) && (Start[-1] == L' ')) --Start;

    /* Finally see how many characters are left, and that's our size */
    PathChars = (USHORT)(Start - PathCopy.Buffer);
    PathCopy.Length = PathChars * sizeof(WCHAR);

    /* Check if this is a COM or LPT port, which has a digit after it */
    if ((PathChars == 4) &&
        (iswdigit(PathCopy.Buffer[3]) && (PathCopy.Buffer[3] != L'0')))
    {
        /* Don't compare the number part, just check for LPT or COM */
        PathCopy.Length -= sizeof(WCHAR);
        if ((RtlEqualUnicodeString(&PathCopy, &RtlpDosLPTDevice, TRUE)) ||
            (RtlEqualUnicodeString(&PathCopy, &RtlpDosCOMDevice, TRUE)))
        {
            /* Found it */
            ReturnLength = sizeof(L"COM1") - sizeof(WCHAR);
            return MAKELONG(ReturnLength, ReturnOffset);
        }
    }
    else if ((PathChars == 3) &&
             ((RtlEqualUnicodeString(&PathCopy, &RtlpDosPRNDevice, TRUE)) ||
              (RtlEqualUnicodeString(&PathCopy, &RtlpDosAUXDevice, TRUE)) ||
              (RtlEqualUnicodeString(&PathCopy, &RtlpDosNULDevice, TRUE)) ||
              (RtlEqualUnicodeString(&PathCopy, &RtlpDosCONDevice, TRUE))))
    {
        /* Otherwise this was something like AUX, NUL, PRN, or CON */
        ReturnLength = sizeof(L"AUX") - sizeof(WCHAR);
        return MAKELONG(ReturnLength, ReturnOffset);
    }

    /* Otherwise, this is not a valid DOS device */
    return 0;
}

NTSTATUS
NTAPI
RtlpCheckDeviceName(IN PUNICODE_STRING FileName,
                    IN ULONG Length,
                    OUT PBOOLEAN NameInvalid)
{
    PWCHAR Buffer;
    NTSTATUS Status;

    /* Allocate a large enough buffer */
    Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, FileName->Length);
    if (Buffer)
    {
        /* Assume failure */
        *NameInvalid = TRUE;

        /* Copy the filename */
        RtlCopyMemory(Buffer, FileName->Buffer, FileName->Length);

        /* And add a dot at the end */
        Buffer[Length / sizeof(WCHAR)] = L'.';
        Buffer[(Length / sizeof(WCHAR)) + 1] = UNICODE_NULL;

        /* Check if the file exists or not */
        *NameInvalid = RtlDoesFileExists_U(Buffer) ? FALSE: TRUE;

        /* Get rid of the buffer now */
        Status = RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
    }
    else
    {
        /* Assume the name is ok, but fail the call */
        *NameInvalid = FALSE;
        Status = STATUS_NO_MEMORY;
    }

    /* Return the status */
    return Status;
}



/******************************************************************
 *    RtlpCollapsePath (from WINE)
 *
 * Helper for RtlGetFullPathName_U
 *
 * 1) Converts slashes into backslashes and gets rid of duplicated ones;
 * 2) Gets rid of . and .. components in the path.
 *
 * Returns the full path length without its terminating NULL character.
 */
static ULONG
RtlpCollapsePath(PWSTR Path, /* ULONG PathBufferSize, ULONG PathLength, */ ULONG mark, BOOLEAN SkipTrailingPathSeparators)
{
    PWSTR p, next;

    // FIXME: Do not suppose NULL-terminated strings!!

    SIZE_T PathLength = wcslen(Path);
    PWSTR EndBuffer = Path + PathLength; // Path + PathBufferSize / sizeof(WCHAR);
    PWSTR EndPath;

    /* Convert slashes into backslashes */
    for (p = Path; *p; p++)
    {
        if (*p == L'/') *p = L'\\';
    }

    /* Collapse duplicate backslashes */
    next = Path + max( 1, mark );
    for (p = next; *p; p++)
    {
        if (*p != L'\\' || next[-1] != L'\\') *next++ = *p;
    }
    *next = UNICODE_NULL;
    EndPath = next;

    p = Path + mark;
    while (*p)
    {
        if (*p == L'.')
        {
            switch (p[1])
            {
                case UNICODE_NULL:  /* final . */
                    if (p > Path + mark) p--;
                    *p = UNICODE_NULL;
                    EndPath = p;
                    continue;

                case L'\\': /* .\ component */
                    next = p + 2;
                    // ASSERT(EndPath - next == wcslen(next));
                    RtlMoveMemory(p, next, (EndPath - next + 1) * sizeof(WCHAR));
                    EndPath -= (next - p);
                    continue;

                case L'.':
                    if (p[2] == L'\\')  /* ..\ component */
                    {
                        next = p + 3;
                        if (p > Path + mark)
                        {
                            p--;
                            while (p > Path + mark && p[-1] != L'\\') p--;
                        }
                        // ASSERT(EndPath - next == wcslen(next));
                        RtlMoveMemory(p, next, (EndPath - next + 1) * sizeof(WCHAR));
                        EndPath -= (next - p);
                        continue;
                    }
                    else if (p[2] == UNICODE_NULL)  /* final .. */
                    {
                        if (p > Path + mark)
                        {
                            p--;
                            while (p > Path + mark && p[-1] != L'\\') p--;
                            if (p > Path + mark) p--;
                        }
                        *p = UNICODE_NULL;
                        EndPath = p;
                        continue;
                    }
                    break;
            }
        }

        /* Skip to the next component */
        while (*p && *p != L'\\') p++;
        if (*p == L'\\')
        {
            /* Remove last dot in previous dir name */
            if (p > Path + mark && p[-1] == L'.')
            {
                // ASSERT(EndPath - p == wcslen(p));
                RtlMoveMemory(p - 1, p, (EndPath - p + 1) * sizeof(WCHAR));
                EndPath--;
            }
            else
            {
                p++;
            }
        }
    }

    /* Remove trailing backslashes if needed (after the UNC part if it exists) */
    if (SkipTrailingPathSeparators)
    {
        while (p > Path + mark && IS_PATH_SEPARATOR(p[-1])) p--;
    }

    /* Remove trailing spaces and dots (for all the path) */
    while (p > Path && (p[-1] == L' ' || p[-1] == L'.')) p--;

    /*
     * Zero-out the discarded buffer zone, starting just after
     * the path string and going up to the end of the buffer.
     * It also NULL-terminate the path string.
     */
    ASSERT(EndBuffer >= p);
    RtlZeroMemory(p, (EndBuffer - p + 1) * sizeof(WCHAR));

    /* Return the real path length */
    PathLength = (p - Path);
    // ASSERT(PathLength == wcslen(Path));
    return (PathLength * sizeof(WCHAR));
}

/******************************************************************
 *    RtlpSkipUNCPrefix (from WINE)
 *
 * Helper for RtlGetFullPathName_U
 *
 * Skips the \\share\dir part of a file name and returns the new position
 * (which can point on the last backslash of "dir\").
 */
static SIZE_T
RtlpSkipUNCPrefix(PCWSTR FileNameBuffer)
{
    PCWSTR UncPath = FileNameBuffer + 2;
    DPRINT("RtlpSkipUNCPrefix(%S)\n", FileNameBuffer);

    while (*UncPath && !IS_PATH_SEPARATOR(*UncPath)) UncPath++;  /* share name */
    while (IS_PATH_SEPARATOR(*UncPath)) UncPath++;
    while (*UncPath && !IS_PATH_SEPARATOR(*UncPath)) UncPath++;  /* dir name */
    /* while (IS_PATH_SEPARATOR(*UncPath)) UncPath++; */

    return (UncPath - FileNameBuffer);
}

NTSTATUS
NTAPI
RtlpApplyLengthFunction(IN ULONG Flags,
                        IN ULONG Type,
                        IN PVOID UnicodeStringOrUnicodeStringBuffer,
                        IN NTSTATUS(NTAPI* LengthFunction)(ULONG, PUNICODE_STRING, PULONG))
{
    NTSTATUS Status;
    PUNICODE_STRING String;
    ULONG Length;

    if (Flags || UnicodeStringOrUnicodeStringBuffer == NULL || LengthFunction == NULL)
    {
        DPRINT1("ERROR: Flags=0x%x, UnicodeStringOrUnicodeStringBuffer=%p, LengthFunction=%p\n",
            Flags, UnicodeStringOrUnicodeStringBuffer, LengthFunction);
        return STATUS_INVALID_PARAMETER;
    }

    if (Type == sizeof(UNICODE_STRING))
    {
        String = (PUNICODE_STRING)UnicodeStringOrUnicodeStringBuffer;
    }
    else if (Type == sizeof(RTL_UNICODE_STRING_BUFFER))
    {
        String = &((PRTL_UNICODE_STRING_BUFFER)UnicodeStringOrUnicodeStringBuffer)->String;
    }
    else
    {
        DPRINT1("ERROR: Type = %u\n", Type);
        return STATUS_INVALID_PARAMETER;
    }

    Length = 0;
    Status = LengthFunction(0, String, &Length);
    if (!NT_SUCCESS(Status))
        return Status;

    if (Length > UNICODE_STRING_MAX_CHARS)
        return STATUS_NAME_TOO_LONG;

    String->Length = (USHORT)(Length * sizeof(WCHAR));

    if (Type == sizeof(RTL_UNICODE_STRING_BUFFER))
    {
        String->Buffer[Length] = UNICODE_NULL;
    }

    return STATUS_SUCCESS;
}

NTSTATUS
NTAPI
RtlGetLengthWithoutLastFullDosOrNtPathElement(IN ULONG Flags,
                                              IN PCUNICODE_STRING Path,
                                              OUT PULONG LengthOut)
{
    static const UNICODE_STRING PathDividers = RTL_CONSTANT_STRING(L"\\/");
    USHORT Position;
    RTL_PATH_TYPE PathType;

    /* All failure paths have this in common, so simplify code */
    if (LengthOut)
        *LengthOut = 0;

    if (Flags || !Path || !LengthOut)
    {
        return STATUS_INVALID_PARAMETER;
    }

    if ((Path->Length / sizeof(WCHAR)) == 0)
    {
        /* Nothing to do here */
        return STATUS_SUCCESS;
    }


    PathType = RtlDetermineDosPathNameType_Ustr(Path);
    switch (PathType)
    {
    case RtlPathTypeLocalDevice:
        // Handle \\\\?\\C:\\ with the last ':' or '\\' missing:
        if (Path->Length / sizeof(WCHAR) < 7 ||
            Path->Buffer[5] != ':' ||
            !IS_PATH_SEPARATOR(Path->Buffer[6]))
        {
            return STATUS_INVALID_PARAMETER;
        }
        break;
    case RtlPathTypeRooted:
        // "\\??\\"
        break;
    case RtlPathTypeUncAbsolute:
        // "\\\\"
        break;
    case RtlPathTypeDriveAbsolute:
        // "C:\\"
        break;
    default:
        return STATUS_INVALID_PARAMETER;
    }

    /* Find the last path separator */
    if (!NT_SUCCESS(RtlFindCharInUnicodeString(RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END, Path, &PathDividers, &Position)))
        Position = 0;

    /* Is it the last char of the string? */
    if (Position && Position + sizeof(WCHAR) == Path->Length)
    {
        UNICODE_STRING Tmp = *Path;
        Tmp.Length = Position;

        /* Keep walking path separators to eliminate multiple next to eachother */
        while (Tmp.Length > sizeof(WCHAR) && IS_PATH_SEPARATOR(Tmp.Buffer[Tmp.Length / sizeof(WCHAR)]))
            Tmp.Length -= sizeof(WCHAR);

        /* Find the previous occurence */
        if (!NT_SUCCESS(RtlFindCharInUnicodeString(RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END, &Tmp, &PathDividers, &Position)))
            Position = 0;
    }

    /* Simplify code by working in chars instead of bytes */
    if (Position)
        Position /= sizeof(WCHAR);

    if (Position)
    {
        // Keep walking path separators to eliminate multiple next to eachother, but ensure we leave one in place!
        while (Position > 1 && IS_PATH_SEPARATOR(Path->Buffer[Position - 1]))
            Position--;
    }

    if (Position > 0)
    {
        /* Return a length, not an index */
        *LengthOut = Position + 1;
    }

    return STATUS_SUCCESS;
}

NTSTATUS
NTAPI
RtlComputePrivatizedDllName_U(
    _In_ PUNICODE_STRING DllName,
    _Inout_ PUNICODE_STRING RealName,
    _Inout_ PUNICODE_STRING LocalName)
{
    static const UNICODE_STRING ExtensionChar = RTL_CONSTANT_STRING(L".");

    USHORT Position;
    UNICODE_STRING ImagePathName, DllNameOnly, CopyRealName, CopyLocalName;
    BOOLEAN HasExtension;
    ULONG RequiredSize;
    NTSTATUS Status;
    C_ASSERT(sizeof(UNICODE_NULL) == sizeof(WCHAR));

    CopyRealName = *RealName;
    CopyLocalName = *LocalName;


    /* Get the image path */
    ImagePathName = RtlGetCurrentPeb()->ProcessParameters->ImagePathName;

    /* Check if it's not normalized */
    if (!(RtlGetCurrentPeb()->ProcessParameters->Flags & RTL_USER_PROCESS_PARAMETERS_NORMALIZED))
    {
        /* Normalize it */
        ImagePathName.Buffer = (PWSTR)((ULONG_PTR)ImagePathName.Buffer + (ULONG_PTR)RtlGetCurrentPeb()->ProcessParameters);
    }


    if (!NT_SUCCESS(RtlFindCharInUnicodeString(RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END,
                                               DllName, &RtlpPathDividers, &Position)))
    {
        DllNameOnly = *DllName;
    }
    else
    {
        /* Just keep the dll name, ignore path components */
        Position += sizeof(WCHAR);
        DllNameOnly.Buffer = DllName->Buffer + Position / sizeof(WCHAR);
        DllNameOnly.Length = DllName->Length - Position;
        DllNameOnly.MaximumLength = DllName->MaximumLength - Position;
    }

    if (!NT_SUCCESS(RtlFindCharInUnicodeString(RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END,
                                               &DllNameOnly, &ExtensionChar, &Position)))
    {
        Position = 0;
    }

    HasExtension = Position > 1;

    /* First we create the c:\path\processname.exe.Local\something.dll path */
    RequiredSize = ImagePathName.Length + RtlpDotLocal.Length + DllNameOnly.Length +
        (HasExtension ? 0 : RtlpDefaultExtension.Length) + sizeof(UNICODE_NULL);

    /* This is not going to work out */
    if (RequiredSize > UNICODE_STRING_MAX_BYTES)
        return STATUS_NAME_TOO_LONG;

    /* We need something extra */
    if (RequiredSize > CopyLocalName.MaximumLength)
    {
        CopyLocalName.Buffer = RtlpAllocateStringMemory(RequiredSize, TAG_USTR);
        if (CopyLocalName.Buffer == NULL)
            return STATUS_NO_MEMORY;
        CopyLocalName.MaximumLength = RequiredSize;
    }
    /* Now build the entire path */
    CopyLocalName.Length = 0;
    Status = RtlAppendUnicodeStringToString(&CopyLocalName, &ImagePathName);
    ASSERT(NT_SUCCESS(Status));
    if (NT_SUCCESS(Status))
    {
        Status = RtlAppendUnicodeStringToString(&CopyLocalName, &RtlpDotLocal);
        ASSERT(NT_SUCCESS(Status));
    }
    if (NT_SUCCESS(Status))
    {
        Status = RtlAppendUnicodeStringToString(&CopyLocalName, &DllNameOnly);
        ASSERT(NT_SUCCESS(Status));
    }
    /* Do we need to append an extension? */
    if (NT_SUCCESS(Status) && !HasExtension)
    {
        Status = RtlAppendUnicodeStringToString(&CopyLocalName, &RtlpDefaultExtension);
        ASSERT(NT_SUCCESS(Status));
    }

    if (NT_SUCCESS(Status))
    {
        /* then we create the c:\path\something.dll path */
        if (NT_SUCCESS(RtlFindCharInUnicodeString(RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END,
                                                  &ImagePathName, &RtlpPathDividers, &Position)))
        {
            ImagePathName.Length = Position + sizeof(WCHAR);
        }

        RequiredSize = ImagePathName.Length + DllNameOnly.Length +
            (HasExtension ? 0 : RtlpDefaultExtension.Length) + sizeof(UNICODE_NULL);

        if (RequiredSize >= UNICODE_STRING_MAX_BYTES)
        {
            Status = STATUS_NAME_TOO_LONG;
        }
        else
        {
            if (RequiredSize > CopyRealName.MaximumLength)
            {
                CopyRealName.Buffer = RtlpAllocateStringMemory(RequiredSize, TAG_USTR);
                if (CopyRealName.Buffer == NULL)
                    Status = STATUS_NO_MEMORY;
                CopyRealName.MaximumLength = RequiredSize;
            }
            CopyRealName.Length = 0;
            if (NT_SUCCESS(Status))
            {
                Status = RtlAppendUnicodeStringToString(&CopyRealName, &ImagePathName);
                ASSERT(NT_SUCCESS(Status));
            }
            if (NT_SUCCESS(Status))
            {
                Status = RtlAppendUnicodeStringToString(&CopyRealName, &DllNameOnly);
                ASSERT(NT_SUCCESS(Status));
            }
            if (NT_SUCCESS(Status) && !HasExtension)
            {
                Status = RtlAppendUnicodeStringToString(&CopyRealName, &RtlpDefaultExtension);
                ASSERT(NT_SUCCESS(Status));
            }
        }
    }

    if (!NT_SUCCESS(Status))
    {
        if (CopyRealName.Buffer && CopyRealName.Buffer != RealName->Buffer)
            RtlpFreeStringMemory(CopyRealName.Buffer, TAG_USTR);
        if (CopyLocalName.Buffer && CopyLocalName.Buffer != LocalName->Buffer)
            RtlpFreeStringMemory(CopyLocalName.Buffer, TAG_USTR);
        return Status;
    }

    *RealName = CopyRealName;
    *LocalName = CopyLocalName;
    return STATUS_SUCCESS;
}

ULONG
NTAPI
RtlGetFullPathName_Ustr(
    _In_ PUNICODE_STRING FileName,
    _In_ ULONG Size,
    _Out_z_bytecap_(Size) PWSTR Buffer,
    _Out_opt_ PCWSTR *ShortName,
    _Out_opt_ PBOOLEAN InvalidName,
    _Out_ RTL_PATH_TYPE *PathType)
{
    NTSTATUS Status;
    PWCHAR FileNameBuffer;
    ULONG FileNameLength, FileNameChars, DosLength, DosLengthOffset, FullLength;
    BOOLEAN SkipTrailingPathSeparators;
    WCHAR c;


    ULONG               reqsize = 0;
    PCWSTR              ptr;

    PCUNICODE_STRING    CurDirName;
    UNICODE_STRING      EnvVarName, EnvVarValue;
    WCHAR EnvVarNameBuffer[4];

    ULONG  PrefixCut    = 0;    // Where the path really starts (after the skipped prefix)
    PWCHAR Prefix       = NULL; // pointer to the string to be inserted as the new path prefix
    ULONG  PrefixLength = 0;
    PWCHAR Source;
    ULONG  SourceLength;


    /* For now, assume the name is valid */
    DPRINT("Filename: %wZ\n", FileName);
    DPRINT("Size and buffer: %lx %p\n", Size, Buffer);
    if (InvalidName) *InvalidName = FALSE;

    /* Handle initial path type and failure case */
    *PathType = RtlPathTypeUnknown;
    if ((FileName->Length == 0) || (FileName->Buffer[0] == UNICODE_NULL)) return 0;

    /* Break filename into component parts */
    FileNameBuffer = FileName->Buffer;
    FileNameLength = FileName->Length;
    FileNameChars  = FileNameLength / sizeof(WCHAR);

    /* Kill trailing spaces */
    c = FileNameBuffer[FileNameChars - 1];
    while ((FileNameLength != 0) && (c == L' '))
    {
        /* Keep going, ignoring the spaces */
        FileNameLength -= sizeof(WCHAR);
        if (FileNameLength != 0) c = FileNameBuffer[FileNameLength / sizeof(WCHAR) - 1];
    }

    /* Check if anything is left */
    if (FileNameLength == 0) return 0;

    /*
     * Check whether we'll need to skip trailing path separators in the
     * computed full path name. If the original file name already contained
     * trailing separators, then we keep them in the full path name. On the
     * other hand, if the original name didn't contain any trailing separators
     * then we'll skip it in the full path name.
     */
    SkipTrailingPathSeparators = !IS_PATH_SEPARATOR(FileNameBuffer[FileNameChars - 1]);

    /* Check if this is a DOS name */
    DosLength = RtlIsDosDeviceName_Ustr(FileName);
    DPRINT("DOS length for filename: %lx %wZ\n", DosLength, FileName);
    if (DosLength != 0)
    {
        /* Zero out the short name */
        if (ShortName) *ShortName = NULL;

        /* See comment for RtlIsDosDeviceName_Ustr if this is confusing... */
        DosLengthOffset = HIWORD(DosLength);
        DosLength       = LOWORD(DosLength);

        /* Do we have a DOS length, and does the caller want validity? */
        if (InvalidName && (DosLengthOffset != 0))
        {
            /* Do the check */
            Status = RtlpCheckDeviceName(FileName, DosLengthOffset, InvalidName);

            /* If the check failed, or the name is invalid, fail here */
            if (!NT_SUCCESS(Status)) return 0;
            if (*InvalidName) return 0;
        }

        /* Add the size of the device root and check if it fits in the size */
        FullLength = DosLength + DeviceRootString.Length;
        if (FullLength < Size)
        {
            /* Add the device string */
            RtlMoveMemory(Buffer, DeviceRootString.Buffer, DeviceRootString.Length);

            /* Now add the DOS device name */
            RtlMoveMemory((PCHAR)Buffer + DeviceRootString.Length,
                          (PCHAR)FileNameBuffer + DosLengthOffset,
                          DosLength);

            /* Null terminate */
            *(PWCHAR)((ULONG_PTR)Buffer + FullLength) = UNICODE_NULL;
            return FullLength;
        }

        /* Otherwise, there's no space, so return the buffer size needed */
        if ((FullLength + sizeof(UNICODE_NULL)) > UNICODE_STRING_MAX_BYTES) return 0;
        return FullLength + sizeof(UNICODE_NULL);
    }

    /* Zero-out the destination buffer. FileName must be different from Buffer */
    RtlZeroMemory(Buffer, Size);

    /* Get the path type */
    *PathType = RtlDetermineDosPathNameType_U(FileNameBuffer);



    /**********************************************
     **    CODE REWRITING IS HAPPENING THERE     **
     **********************************************/
    Source       = FileNameBuffer;
    SourceLength = FileNameLength;
    EnvVarValue.Buffer = NULL;

    /* Lock the PEB to get the current directory */
    RtlAcquirePebLock();
    CurDirName = &NtCurrentPeb()->ProcessParameters->CurrentDirectory.DosPath;

    switch (*PathType)
    {
        case RtlPathTypeUncAbsolute:        /* \\foo   */
        {
            PrefixCut = RtlpSkipUNCPrefix(FileNameBuffer);
            break;
        }

        case RtlPathTypeLocalDevice:        /* \\.\foo */
        {
            PrefixCut = 4;
            break;
        }

        case RtlPathTypeDriveAbsolute:      /* c:\foo  */
        {
            ASSERT(FileNameBuffer[1] == L':');
            ASSERT(IS_PATH_SEPARATOR(FileNameBuffer[2]));

            // FileNameBuffer[0] = RtlpUpcaseUnicodeChar(FileNameBuffer[0]);
            Prefix = FileNameBuffer;
            PrefixLength = 3 * sizeof(WCHAR);
            Source += 3;
            SourceLength -= 3 * sizeof(WCHAR);

            PrefixCut = 3;
            break;
        }

        case RtlPathTypeDriveRelative:      /* c:foo   */
        {
            WCHAR CurDrive, NewDrive;

            Source += 2;
            SourceLength -= 2 * sizeof(WCHAR);

            CurDrive = RtlpUpcaseUnicodeChar(CurDirName->Buffer[0]);
            NewDrive = RtlpUpcaseUnicodeChar(FileNameBuffer[0]);

            if ((NewDrive != CurDrive) || CurDirName->Buffer[1] != L':')
            {
                EnvVarNameBuffer[0] = L'=';
                EnvVarNameBuffer[1] = NewDrive;
                EnvVarNameBuffer[2] = L':';
                EnvVarNameBuffer[3] = UNICODE_NULL;

                EnvVarName.Length = 3 * sizeof(WCHAR);
                EnvVarName.MaximumLength = EnvVarName.Length + sizeof(WCHAR);
                EnvVarName.Buffer = EnvVarNameBuffer;

                // FIXME: Is it possible to use the user-given buffer ?
                // RtlInitEmptyUnicodeString(&EnvVarValue, NULL, Size);
                EnvVarValue.Length = 0;
                EnvVarValue.MaximumLength = (USHORT)Size;
                EnvVarValue.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size);
                if (EnvVarValue.Buffer == NULL)
                {
                    Prefix       = NULL;
                    PrefixLength = 0;
                    goto Quit;
                }

                Status = RtlQueryEnvironmentVariable_U(NULL, &EnvVarName, &EnvVarValue);
                switch (Status)
                {
                    case STATUS_SUCCESS:
                        /*
                         * (From Wine)
                         * FIXME: Win2k seems to check that the environment
                         * variable actually points to an existing directory.
                         * If not, root of the drive is used (this seems also
                         * to be the only place in RtlGetFullPathName that the
                         * existence of a part of a path is checked).
                         */
                        EnvVarValue.Buffer[EnvVarValue.Length / sizeof(WCHAR)] = L'\\';
                        Prefix       = EnvVarValue.Buffer;
                        PrefixLength = EnvVarValue.Length + sizeof(WCHAR); /* Append trailing '\\' */
                        break;

                    case STATUS_BUFFER_TOO_SMALL:
                        reqsize = EnvVarValue.Length + SourceLength + sizeof(UNICODE_NULL);
                        goto Quit;

                    default:
                        DPRINT1("RtlQueryEnvironmentVariable_U(\"%wZ\") returned 0x%08lx\n", &EnvVarName, Status);

                        EnvVarNameBuffer[0] = NewDrive;
                        EnvVarNameBuffer[1] = L':';
                        EnvVarNameBuffer[2] = L'\\';
                        EnvVarNameBuffer[3] = UNICODE_NULL;
                        Prefix       = EnvVarNameBuffer;
                        PrefixLength = 3 * sizeof(WCHAR);

                        RtlFreeHeap(RtlGetProcessHeap(), 0, EnvVarValue.Buffer);
                        EnvVarValue.Buffer = NULL;
                        break;
                }
                PrefixCut = 3;
                break;
            }
            /* Fall through */
            DPRINT("RtlPathTypeDriveRelative - Using fall-through to RtlPathTypeRelative\n");
        }

        case RtlPathTypeRelative:           /* foo     */
        {
            Prefix       = CurDirName->Buffer;
            PrefixLength = CurDirName->Length;
            if (CurDirName->Buffer[1] != L':')
            {
                PrefixCut = RtlpSkipUNCPrefix(CurDirName->Buffer);
            }
            else
            {
                PrefixCut = 3;
            }
            break;
        }

        case RtlPathTypeRooted:             /* \xxx    */
        {
            if (CurDirName->Buffer[1] == L':')
            {
                // The path starts with "C:\"
                ASSERT(CurDirName->Buffer[1] == L':');
                ASSERT(IS_PATH_SEPARATOR(CurDirName->Buffer[2]));

                Prefix = CurDirName->Buffer;
                PrefixLength = 3 * sizeof(WCHAR); // Skip "C:\"

                PrefixCut = 3;      // Source index location incremented of + 3
            }
            else
            {
                PrefixCut = RtlpSkipUNCPrefix(CurDirName->Buffer);
                PrefixLength = PrefixCut * sizeof(WCHAR);
                Prefix = CurDirName->Buffer;
            }
            break;
        }

        case RtlPathTypeRootLocalDevice:    /* \\.     */
        {
            Prefix       = DeviceRootString.Buffer;
            PrefixLength = DeviceRootString.Length;
            Source += 3;
            SourceLength -= 3 * sizeof(WCHAR);

            PrefixCut = 4;
            break;
        }

        case RtlPathTypeUnknown:
            goto Quit;
    }

    /* Do we have enough space for storing the full path? */
    reqsize = PrefixLength;
    if (reqsize + SourceLength + sizeof(WCHAR) > Size)
    {
        /* Not enough space, return needed size (including terminating '\0') */
        reqsize += SourceLength + sizeof(WCHAR);
        goto Quit;
    }

    /*
     * Build the full path
     */
    /* Copy the path's prefix */
    if (PrefixLength) RtlMoveMemory(Buffer, Prefix, PrefixLength);
    /* Copy the remaining part of the path */
    RtlMoveMemory(Buffer + PrefixLength / sizeof(WCHAR), Source, SourceLength + sizeof(WCHAR));

    /* Some cleanup */
    Prefix = NULL;
    if (EnvVarValue.Buffer)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, EnvVarValue.Buffer);
        EnvVarValue.Buffer = NULL;
    }

    /*
     * Finally, put the path in canonical form (remove redundant . and ..,
     * (back)slashes...) and retrieve the length of the full path name
     * (without its terminating null character) (in chars).
     */
    reqsize = RtlpCollapsePath(Buffer, /* Size, reqsize, */ PrefixCut, SkipTrailingPathSeparators);

    /* Find the file part, which is present after the last path separator */
    if (ShortName)
    {
        ptr = wcsrchr(Buffer, L'\\');
        if (ptr) ++ptr; // Skip it

        /*
         * For UNC paths, the file part is after the \\share\dir part of the path.
         */
        PrefixCut = (*PathType == RtlPathTypeUncAbsolute ? PrefixCut : 3);

        if (ptr && *ptr && (ptr >= Buffer + PrefixCut))
        {
            *ShortName = ptr;
        }
        else
        {
            /* Zero-out the short name */
            *ShortName = NULL;
        }
    }

Quit:
    /* Release PEB lock */
    RtlReleasePebLock();

    return reqsize;
}

NTSTATUS
NTAPI
RtlpWin32NTNameToNtPathName_U(IN PUNICODE_STRING DosPath,
                              OUT PUNICODE_STRING NtPath,
                              OUT PCWSTR *PartName,
                              OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    ULONG DosLength;
    PWSTR NewBuffer, p;

    /* Validate the input */
    if (!DosPath) return STATUS_OBJECT_NAME_INVALID;

    /* Validate the DOS length */
    DosLength = DosPath->Length;
    if (DosLength >= UNICODE_STRING_MAX_BYTES) return STATUS_NAME_TOO_LONG;

    /* Make space for the new path */
    NewBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
                                0,
                                DosLength + sizeof(UNICODE_NULL));
    if (!NewBuffer) return STATUS_NO_MEMORY;

    /* Copy the prefix, and then the rest of the DOS path, and NULL-terminate */
    RtlCopyMemory(NewBuffer, RtlpDosDevicesPrefix.Buffer, RtlpDosDevicesPrefix.Length);
    RtlCopyMemory((PCHAR)NewBuffer + RtlpDosDevicesPrefix.Length,
                  DosPath->Buffer + RtlpDosDevicesPrefix.Length / sizeof(WCHAR),
                  DosPath->Length - RtlpDosDevicesPrefix.Length);
    NewBuffer[DosLength / sizeof(WCHAR)] = UNICODE_NULL;

    /* Did the caller send a relative name? */
    if (RelativeName)
    {
        /* Zero initialize it */
        RtlInitEmptyUnicodeString(&RelativeName->RelativeName, NULL, 0);
        RelativeName->ContainingDirectory = NULL;
        RelativeName->CurDirRef = 0;
    }

    /* Did the caller request a partial name? */
    if (PartName)
    {
        /* Loop from the back until we find a path separator */
        p = &NewBuffer[DosLength / sizeof(WCHAR)];
        while (--p > NewBuffer)
        {
            /* We found a path separator, move past it */
            if (*p == OBJ_NAME_PATH_SEPARATOR)
            {
                ++p;
                break;
            }
        }

        /* Check whether a separator was found and if something remains */
        if ((p > NewBuffer) && *p)
        {
            /* What follows the path separator is the partial name */
            *PartName = p;
        }
        else
        {
            /* The path ends with a path separator, no partial name */
            *PartName = NULL;
        }
    }

    /* Build the final NT path string */
    NtPath->Buffer = NewBuffer;
    NtPath->Length = (USHORT)DosLength;
    NtPath->MaximumLength = (USHORT)DosLength + sizeof(UNICODE_NULL);
    return STATUS_SUCCESS;
}

NTSTATUS
NTAPI
RtlpDosPathNameToRelativeNtPathName_Ustr(IN BOOLEAN HaveRelative,
                                         IN PCUNICODE_STRING DosName,
                                         OUT PUNICODE_STRING NtName,
                                         OUT PCWSTR *PartName,
                                         OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    WCHAR BigBuffer[MAX_PATH + 1];
    PWCHAR PrefixBuffer, NewBuffer, Buffer;
    ULONG MaxLength, PathLength, PrefixLength, PrefixCut, LengthChars, Length;
    UNICODE_STRING CapturedDosName, PartNameString, FullPath;
    BOOLEAN QuickPath;
    RTL_PATH_TYPE InputPathType, BufferPathType;
    NTSTATUS Status;
    BOOLEAN NameInvalid;
    PCURDIR CurrentDirectory;

    /* Assume MAX_PATH for now */
    DPRINT("Relative: %lx DosName: %wZ NtName: %p, PartName: %p, RelativeName: %p\n",
            HaveRelative, DosName, NtName, PartName, RelativeName);
    MaxLength = sizeof(BigBuffer);

    /* Validate the input */
    if (!DosName) return STATUS_OBJECT_NAME_INVALID;

    /* Capture input string */
    CapturedDosName = *DosName;

    /* Check for the presence or absence of the NT prefix "\\?\" form */
    // if (!RtlPrefixUnicodeString(&RtlpWin32NtRootSlash, &CapturedDosName, FALSE))
    if ((CapturedDosName.Length <= RtlpWin32NtRootSlash.Length) ||
        (CapturedDosName.Buffer[0] != RtlpWin32NtRootSlash.Buffer[0]) ||
        (CapturedDosName.Buffer[1] != RtlpWin32NtRootSlash.Buffer[1]) ||
        (CapturedDosName.Buffer[2] != RtlpWin32NtRootSlash.Buffer[2]) ||
        (CapturedDosName.Buffer[3] != RtlpWin32NtRootSlash.Buffer[3]))
    {
        /* NT prefix not present */

        /* Quick path won't be used */
        QuickPath = FALSE;

        /* Use the static buffer */
        Buffer = BigBuffer;
        MaxLength += RtlpDosDevicesUncPrefix.Length;

        /* Allocate a buffer to hold the path */
        NewBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, MaxLength);
        DPRINT("MaxLength: %lx\n", MaxLength);
        if (!NewBuffer) return STATUS_NO_MEMORY;
    }
    else
    {
        /* NT prefix present */

        /* Use the optimized path after acquiring the lock */
        QuickPath = TRUE;
        NewBuffer = NULL;
    }

    /* Lock the PEB and check if the quick path can be used */
    RtlAcquirePebLock();
    if (QuickPath)
    {
        /* Some simple fixups will get us the correct path */
        DPRINT("Quick path\n");
        Status = RtlpWin32NTNameToNtPathName_U(&CapturedDosName,
                                               NtName,
                                               PartName,
                                               RelativeName);

        /* Release the lock, we're done here */
        RtlReleasePebLock();
        return Status;
    }

    /* Call the main function to get the full path name and length */
    PathLength = RtlGetFullPathName_Ustr(&CapturedDosName,
                                         MAX_PATH * sizeof(WCHAR),
                                         Buffer,
                                         PartName,
                                         &NameInvalid,
                                         &InputPathType);
    if ((NameInvalid) || !(PathLength) || (PathLength > (MAX_PATH * sizeof(WCHAR))))
    {
        /* Invalid name, fail */
        DPRINT("Invalid name: %lx Path Length: %lx\n", NameInvalid, PathLength);
        RtlFreeHeap(RtlGetProcessHeap(), 0, NewBuffer);
        RtlReleasePebLock();
        return STATUS_OBJECT_NAME_INVALID;
    }

    /* Start by assuming the path starts with \??\ (DOS Devices Path) */
    PrefixLength = RtlpDosDevicesPrefix.Length;
    PrefixBuffer = RtlpDosDevicesPrefix.Buffer;
    PrefixCut = 0;

    /* Check where it really is */
    BufferPathType = RtlDetermineDosPathNameType_U(Buffer);
    DPRINT("Buffer: %S Type: %lx\n", Buffer, BufferPathType);
    switch (BufferPathType)
    {
        /* It's actually a UNC path in \??\UNC\ */
        case RtlPathTypeUncAbsolute:
            PrefixLength = RtlpDosDevicesUncPrefix.Length;
            PrefixBuffer = RtlpDosDevicesUncPrefix.Buffer;
            PrefixCut = 2;
            break;

        case RtlPathTypeLocalDevice:
            /* We made a good guess, go with it but skip the \??\ */
            PrefixCut = 4;
            break;

        case RtlPathTypeDriveAbsolute:
        case RtlPathTypeDriveRelative:
        case RtlPathTypeRooted:
        case RtlPathTypeRelative:
            /* Our guess was good, roll with it */
            break;

        /* Nothing else is expected */
        default:
            ASSERT(FALSE);
    }

    /* Now copy the prefix and the buffer */
    RtlCopyMemory(NewBuffer, PrefixBuffer, PrefixLength);
    RtlCopyMemory((PCHAR)NewBuffer + PrefixLength,
                  Buffer + PrefixCut,
                  PathLength - (PrefixCut * sizeof(WCHAR)));

    /* Compute the length */
    Length = PathLength + PrefixLength - PrefixCut * sizeof(WCHAR);
    LengthChars = Length / sizeof(WCHAR);

    /* Setup the actual NT path string and terminate it */
    NtName->Buffer = NewBuffer;
    NtName->Length = (USHORT)Length;
    NtName->MaximumLength = (USHORT)MaxLength;
    NewBuffer[LengthChars] = UNICODE_NULL;
    DPRINT("New buffer: %S\n", NewBuffer);
    DPRINT("NT Name: %wZ\n", NtName);

    /* Check if a partial name was requested */
    if ((PartName) && (*PartName))
    {
        /* Convert to Unicode */
        Status = RtlInitUnicodeStringEx(&PartNameString, *PartName);
        if (NT_SUCCESS(Status))
        {
            /* Set the partial name */
            *PartName = &NewBuffer[LengthChars - (PartNameString.Length / sizeof(WCHAR))];
        }
        else
        {
            /* Fail */
            RtlFreeHeap(RtlGetProcessHeap(), 0, NewBuffer);
            RtlReleasePebLock();
            return Status;
        }
    }

    /* Check if a relative name was asked for */
    if (RelativeName)
    {
        /* Setup the structure */
        RtlInitEmptyUnicodeString(&RelativeName->RelativeName, NULL, 0);
        RelativeName->ContainingDirectory = NULL;
        RelativeName->CurDirRef = NULL;

        /* Check if the input path itself was relative */
        if (InputPathType == RtlPathTypeRelative)
        {
            /* Get current directory */
            CurrentDirectory = &(NtCurrentPeb()->ProcessParameters->CurrentDirectory);
            if (CurrentDirectory->Handle)
            {
                Status = RtlInitUnicodeStringEx(&FullPath, Buffer);
                if (!NT_SUCCESS(Status))
                {
                    RtlFreeHeap(RtlGetProcessHeap(), 0, NewBuffer);
                    RtlReleasePebLock();
                    return Status;
                }

                /* If current directory is bigger than full path, there's no way */
                if (CurrentDirectory->DosPath.Length > FullPath.Length)
                {
                    RtlReleasePebLock();
                    return Status;
                }

                /* File is in current directory */
                if (RtlEqualUnicodeString(&FullPath, &CurrentDirectory->DosPath, TRUE))
                {
                    /* Make relative name string */
                    RelativeName->RelativeName.Buffer = (PWSTR)((ULONG_PTR)NewBuffer + PrefixLength + FullPath.Length - PrefixCut * sizeof(WCHAR));
                    RelativeName->RelativeName.Length = (USHORT)(PathLength - FullPath.Length);
                    /* If relative name starts with \, skip it */
                    if (RelativeName->RelativeName.Buffer[0] == OBJ_NAME_PATH_SEPARATOR)
                    {
                        RelativeName->RelativeName.Buffer++;
                        RelativeName->RelativeName.Length -= sizeof(WCHAR);
                    }
                    RelativeName->RelativeName.MaximumLength = RelativeName->RelativeName.Length;
                    DPRINT("RelativeName: %wZ\n", &(RelativeName->RelativeName));

                    if (!HaveRelative)
                    {
                        RelativeName->ContainingDirectory = CurrentDirectory->Handle;
                        return Status;
                    }

                    /* Give back current directory data & reference counter */
                    RelativeName->CurDirRef = RtlpCurDirRef;
                    if (RelativeName->CurDirRef)
                    {
                        InterlockedIncrement(&RtlpCurDirRef->RefCount);
                    }

                    RelativeName->ContainingDirectory = CurrentDirectory->Handle;
                }
            }
        }
    }

    /* Done */
    RtlReleasePebLock();
    return STATUS_SUCCESS;
}

NTSTATUS
NTAPI
RtlpDosPathNameToRelativeNtPathName_U(IN BOOLEAN HaveRelative,
                                      IN PCWSTR DosName,
                                      OUT PUNICODE_STRING NtName,
                                      OUT PCWSTR *PartName,
                                      OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    NTSTATUS Status;
    UNICODE_STRING NameString;

    /* Create the unicode name */
    Status = RtlInitUnicodeStringEx(&NameString, DosName);
    if (NT_SUCCESS(Status))
    {
        /* Call the unicode function */
        Status = RtlpDosPathNameToRelativeNtPathName_Ustr(HaveRelative,
                                                          &NameString,
                                                          NtName,
                                                          PartName,
                                                          RelativeName);
    }

    /* Return status */
    return Status;
}

BOOLEAN
NTAPI
RtlDosPathNameToRelativeNtPathName_Ustr(IN PCUNICODE_STRING DosName,
                                        OUT PUNICODE_STRING NtName,
                                        OUT PCWSTR *PartName,
                                        OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    /* Call the internal function */
    ASSERT(RelativeName);
    return NT_SUCCESS(RtlpDosPathNameToRelativeNtPathName_Ustr(TRUE,
                                                               DosName,
                                                               NtName,
                                                               PartName,
                                                               RelativeName));
}

BOOLEAN
NTAPI
RtlDoesFileExists_UstrEx(IN PCUNICODE_STRING FileName,
                         IN BOOLEAN SucceedIfBusy)
{
    BOOLEAN Result;
    RTL_RELATIVE_NAME_U RelativeName;
    UNICODE_STRING NtPathName;
    PVOID Buffer;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    FILE_BASIC_INFORMATION BasicInformation;

    /* Get the NT Path */
    Result = RtlDosPathNameToRelativeNtPathName_Ustr(FileName,
                                                     &NtPathName,
                                                     NULL,
                                                     &RelativeName);
    if (!Result) return FALSE;

    /* Save the buffer */
    Buffer = NtPathName.Buffer;

    /* Check if we have a relative name */
    if (RelativeName.RelativeName.Length)
    {
        /* Use it */
        NtPathName = RelativeName.RelativeName;
    }
    else
    {
        /* Otherwise ignore it */
        RelativeName.ContainingDirectory = NULL;
    }

    /* Initialize the object attributes */
    InitializeObjectAttributes(&ObjectAttributes,
                               &NtPathName,
                               OBJ_CASE_INSENSITIVE,
                               RelativeName.ContainingDirectory,
                               NULL);

    /* Query the attributes and free the buffer now */
    Status = ZwQueryAttributesFile(&ObjectAttributes, &BasicInformation);
    RtlReleaseRelativeName(&RelativeName);
    RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);

    /* Check if we failed */
    if (!NT_SUCCESS(Status))
    {
        /* Check if we failed because the file is in use */
        if ((Status == STATUS_SHARING_VIOLATION) ||
            (Status == STATUS_ACCESS_DENIED))
        {
            /* Check if the caller wants this to be considered OK */
            Result = SucceedIfBusy ? TRUE : FALSE;
        }
        else
        {
            /* A failure because the file didn't exist */
            Result = FALSE;
        }
    }
    else
    {
        /* The file exists */
        Result = TRUE;
    }

    /* Return the result */
    return Result;
}

BOOLEAN
NTAPI
RtlDoesFileExists_UStr(IN PUNICODE_STRING FileName)
{
    /* Call the updated API */
    return RtlDoesFileExists_UstrEx(FileName, TRUE);
}

BOOLEAN
NTAPI
RtlDoesFileExists_UEx(IN PCWSTR FileName,
                      IN BOOLEAN SucceedIfBusy)
{
    UNICODE_STRING NameString;

    /* Create the unicode name*/
    if (NT_SUCCESS(RtlInitUnicodeStringEx(&NameString, FileName)))
    {
        /* Call the unicode function */
        return RtlDoesFileExists_UstrEx(&NameString, SucceedIfBusy);
    }

    /* Fail */
    return FALSE;
}

/* PUBLIC FUNCTIONS ***********************************************************/

/*
 * @implemented
 */
VOID
NTAPI
RtlReleaseRelativeName(IN PRTL_RELATIVE_NAME_U RelativeName)
{
    /* Check if a directory reference was grabbed */
    if (RelativeName->CurDirRef)
    {
        /* Decrease reference count */
        if (!InterlockedDecrement(&RelativeName->CurDirRef->RefCount))
        {
            /* If no one uses it any longer, close handle & free */
            NtClose(RelativeName->CurDirRef->Handle);
            RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeName->CurDirRef);
        }
        RelativeName->CurDirRef = NULL;
    }
}

/*
 * @implemented
 */
ULONG
NTAPI
RtlGetLongestNtPathLength(VOID)
{
    /*
     * The longest NT path is a DOS path that actually sits on a UNC path (ie:
     * a mapped network drive), which is accessed through the DOS Global?? path.
     * This is, and has always been equal to, 269 characters, except in Wine
     * which claims this is 277. Go figure.
     */
    return MAX_PATH + RtlpDosDevicesUncPrefix.Length / sizeof(WCHAR) + sizeof(ANSI_NULL);
}

/*
 * @implemented
 * @note: the export is called RtlGetLengthWithoutTrailingPathSeperators
 *        (with a 'e' instead of a 'a' in "Seperators").
 */
NTSTATUS
NTAPI
RtlGetLengthWithoutTrailingPathSeparators(IN  ULONG Flags,
                                          IN  PCUNICODE_STRING PathString,
                                          OUT PULONG Length)
{
    ULONG NumChars;

    /* Parameters validation */
    if (Length == NULL) return STATUS_INVALID_PARAMETER;

    *Length = 0;

    if (PathString == NULL) return STATUS_INVALID_PARAMETER;

    /* No flags are supported yet */
    if (Flags != 0) return STATUS_INVALID_PARAMETER;

    NumChars = PathString->Length / sizeof(WCHAR);

    /*
     * Notice that we skip the last character, therefore:
     * - if we have: "some/path/f" we test for: "some/path/"
     * - if we have: "some/path/"  we test for: "some/path"
     * - if we have: "s" we test for: ""
     * - if we have: "" then NumChars was already zero and we aren't there
     */

    while (NumChars > 0 && IS_PATH_SEPARATOR(PathString->Buffer[NumChars - 1]))
    {
        --NumChars;
    }

    *Length = NumChars;
    return STATUS_SUCCESS;
}

/*
 * @implemented
 */
RTL_PATH_TYPE
NTAPI
RtlDetermineDosPathNameType_U(IN PCWSTR Path)
{
    DPRINT("RtlDetermineDosPathNameType_U %S\n", Path);

    /* Unlike the newer RtlDetermineDosPathNameType_U we assume 4 characters */
    if (IS_PATH_SEPARATOR(Path[0]))
    {
        if (!IS_PATH_SEPARATOR(Path[1])) return RtlPathTypeRooted;                /* \x             */
        if ((Path[2] != L'.') && (Path[2] != L'?')) return RtlPathTypeUncAbsolute;/* \\x            */
        if (IS_PATH_SEPARATOR(Path[3])) return RtlPathTypeLocalDevice;            /* \\.\x or \\?\x */
        if (Path[3]) return RtlPathTypeUncAbsolute;                               /* \\.x or \\?x   */
        return RtlPathTypeRootLocalDevice;                                        /* \\. or \\?     */
    }
    else
    {
        if (!(Path[0]) || (Path[1] != L':')) return RtlPathTypeRelative;          /* x              */
        if (IS_PATH_SEPARATOR(Path[2])) return RtlPathTypeDriveAbsolute;          /* x:\            */
        return RtlPathTypeDriveRelative;                                          /* x:             */
    }
}

/*
 * @implemented
 */
ULONG
NTAPI
RtlIsDosDeviceName_U(IN PCWSTR Path)
{
    UNICODE_STRING PathString;
    NTSTATUS Status;

    /* Build the string */
    Status = RtlInitUnicodeStringEx(&PathString, Path);
    if (!NT_SUCCESS(Status)) return 0;

    /*
     * Returns 0 if name is not valid DOS device name, or DWORD with
     * offset in bytes to DOS device name from beginning of buffer in high word
     * and size in bytes of DOS device name in low word
     */
     return RtlIsDosDeviceName_Ustr(&PathString);
}

/*
 * @implemented
 */
ULONG
NTAPI
RtlGetCurrentDirectory_U(
    _In_ ULONG MaximumLength,
    _Out_bytecap_(MaximumLength) PWSTR Buffer)
{
    ULONG Length, Bytes;
    PCURDIR CurDir;
    PWSTR CurDirName;
    DPRINT("RtlGetCurrentDirectory %lu %p\n", MaximumLength, Buffer);

    /* Lock the PEB to get the current directory */
    RtlAcquirePebLock();
    CurDir = &NtCurrentPeb()->ProcessParameters->CurrentDirectory;

    /* Get the buffer and character length */
    CurDirName = CurDir->DosPath.Buffer;
    Length = CurDir->DosPath.Length / sizeof(WCHAR);
    ASSERT((CurDirName != NULL) && (Length > 0));

    /*
     * DosPath.Buffer should always have a trailing slash. There is an assert
     * below which checks for this.
     *
     * This function either returns x:\ for a root (keeping the original buffer)
     * or it returns x:\path\foo for a directory (replacing the trailing slash
     * with a NULL.
     */
    Bytes = Length * sizeof(WCHAR);
    if ((Length <= 1) || (CurDirName[Length - 2] == L':'))
    {
        /* Check if caller does not have enough space */
        if (MaximumLength <= Bytes)
        {
            /* Call has no space for it, fail, add the trailing slash */
            RtlReleasePebLock();
            return Bytes + sizeof(OBJ_NAME_PATH_SEPARATOR);
        }
    }
    else
    {
        /* Check if caller does not have enough space */
        if (MaximumLength < Bytes)
        {
            /* Call has no space for it, fail */
            RtlReleasePebLock();
            return Bytes;
        }
    }

    /* Copy the buffer since we seem to have space */
    RtlCopyMemory(Buffer, CurDirName, Bytes);

    /* The buffer should end with a path separator */
    ASSERT(Buffer[Length - 1] == OBJ_NAME_PATH_SEPARATOR);

    /* Again check for our two cases (drive root vs path) */
    if ((Length <= 1) || (Buffer[Length - 2] != L':'))
    {
        /* Replace the trailing slash with a null */
        Buffer[Length - 1] = UNICODE_NULL;
        --Length;
    }
    else
    {
        /* Append the null char since there's no trailing slash */
        Buffer[Length] = UNICODE_NULL;
    }

    /* Release PEB lock */
    RtlReleasePebLock();
    DPRINT("CurrentDirectory %S\n", Buffer);
    return Length * sizeof(WCHAR);
}

/*
 * @implemented
 */
NTSTATUS
NTAPI
RtlSetCurrentDirectory_U(IN PUNICODE_STRING Path)
{
    PCURDIR CurDir;
    NTSTATUS Status;
    RTL_PATH_TYPE PathType;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING FullPath, NtName;
    PRTLP_CURDIR_REF OldCurDir = NULL;
    OBJECT_ATTRIBUTES ObjectAttributes;
    FILE_FS_DEVICE_INFORMATION FileFsDeviceInfo;
    ULONG SavedLength, CharLength, FullPathLength;
    HANDLE OldHandle = NULL, CurDirHandle = NULL, OldCurDirHandle = NULL;

    DPRINT("RtlSetCurrentDirectory_U %wZ\n", Path);

    /* Initialize for failure case */
    RtlInitEmptyUnicodeString(&NtName, NULL, 0);

    /* Can't set current directory on DOS device */
    if (RtlIsDosDeviceName_Ustr(Path))
    {
        return STATUS_NOT_A_DIRECTORY;
    }

    /* Get current directory */
    RtlAcquirePebLock();
    CurDir = &NtCurrentPeb()->ProcessParameters->CurrentDirectory;

    /* Check if we have to drop current handle */
    if (((ULONG_PTR)(CurDir->Handle) & RTL_CURDIR_ALL_FLAGS) == RTL_CURDIR_DROP_OLD_HANDLE)
    {
        OldHandle = CurDir->Handle;
        CurDir->Handle = NULL;
    }

    /* Allocate a buffer for full path (using max possible length */
    FullPath.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, CurDir->DosPath.MaximumLength);
    if (!FullPath.Buffer)
    {
        Status = STATUS_NO_MEMORY;
        goto Leave;
    }

    /* Init string */
    FullPath.Length = 0;
    FullPath.MaximumLength = CurDir->DosPath.MaximumLength;

    /* Get new directory full path */
    FullPathLength = RtlGetFullPathName_Ustr(Path, FullPath.MaximumLength, FullPath.Buffer, NULL, NULL, &PathType);
    if (!FullPathLength)
    {
        Status = STATUS_OBJECT_NAME_INVALID;
        goto Leave;
    }

    SavedLength = FullPath.MaximumLength;
    CharLength = FullPathLength / sizeof(WCHAR);

    if (FullPathLength > FullPath.MaximumLength)
    {
        Status = STATUS_NAME_TOO_LONG;
        goto Leave;
    }

    /* Translate it to NT name */
    if (!RtlDosPathNameToNtPathName_U(FullPath.Buffer, &NtName, NULL, NULL))
    {
        Status = STATUS_OBJECT_NAME_INVALID;
        goto Leave;
    }

   InitializeObjectAttributes(&ObjectAttributes, &NtName,
                              OBJ_CASE_INSENSITIVE | OBJ_INHERIT,
                              NULL, NULL);

    /* If previous current directory was removable, then check it for dropping */
    if (((ULONG_PTR)(CurDir->Handle) & RTL_CURDIR_ALL_FLAGS) == RTL_CURDIR_ALL_FLAGS)
    {
        /* Get back normal handle */
        CurDirHandle = (HANDLE)((ULONG_PTR)(CurDir->Handle) & ~RTL_CURDIR_ALL_FLAGS);
        CurDir->Handle = NULL;

        /* Get device information */
        Status = NtQueryVolumeInformationFile(CurDirHandle,
                                              &IoStatusBlock,
                                              &FileFsDeviceInfo,
                                              sizeof(FileFsDeviceInfo),
                                              FileFsDeviceInformation);
        /* Retry without taking care of removable device */
        if (!NT_SUCCESS(Status))
        {
            Status = RtlSetCurrentDirectory_U(Path);
            goto Leave;
        }
    }
    else
    {
        /* Open directory */
        Status = NtOpenFile(&CurDirHandle,
                            SYNCHRONIZE | FILE_TRAVERSE,
                            &ObjectAttributes,
                            &IoStatusBlock,
                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                            FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
        if (!NT_SUCCESS(Status)) goto Leave;

        /* Get device information */
        Status = NtQueryVolumeInformationFile(CurDirHandle,
                                              &IoStatusBlock,
                                              &FileFsDeviceInfo,
                                              sizeof(FileFsDeviceInfo),
                                              FileFsDeviceInformation);
        if (!NT_SUCCESS(Status)) goto Leave;
    }

    /* If device is removable, mark handle */
    if (FileFsDeviceInfo.Characteristics & FILE_REMOVABLE_MEDIA)
    {
        CurDirHandle = (HANDLE)((ULONG_PTR)CurDirHandle | RTL_CURDIR_IS_REMOVABLE);
    }

    FullPath.Length = (USHORT)FullPathLength;

    /* If full path isn't \ terminated, do it */
    if (FullPath.Buffer[CharLength - 1] != OBJ_NAME_PATH_SEPARATOR)
    {
        if ((CharLength + 1) * sizeof(WCHAR) > SavedLength)
        {
            Status = STATUS_NAME_TOO_LONG;
            goto Leave;
        }

        FullPath.Buffer[CharLength] = OBJ_NAME_PATH_SEPARATOR;
        FullPath.Buffer[CharLength + 1] = UNICODE_NULL;
        FullPath.Length += sizeof(WCHAR);
    }

    /* If we have previous current directory with only us as reference, save it */
    if (RtlpCurDirRef != NULL && RtlpCurDirRef->RefCount == 1)
    {
        OldCurDirHandle = RtlpCurDirRef->Handle;
    }
    else
    {
        /* Allocate new current directory struct saving previous one */
        OldCurDir = RtlpCurDirRef;
        RtlpCurDirRef = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(RTLP_CURDIR_REF));
        if (!RtlpCurDirRef)
        {
            RtlpCurDirRef = OldCurDir;
            OldCurDir = NULL;
            Status = STATUS_NO_MEMORY;
            goto Leave;
        }

        /* Set reference to 1 (us) */
        RtlpCurDirRef->RefCount = 1;
    }

    /* Save new data */
    CurDir->Handle = CurDirHandle;
    RtlpCurDirRef->Handle = CurDirHandle;
    CurDirHandle = NULL;

    /* Copy full path */
    RtlCopyMemory(CurDir->DosPath.Buffer, FullPath.Buffer, FullPath.Length + sizeof(WCHAR));
    CurDir->DosPath.Length = FullPath.Length;

    Status = STATUS_SUCCESS;

Leave:
    RtlReleasePebLock();

    if (FullPath.Buffer)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, FullPath.Buffer);
    }

    if (NtName.Buffer)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, NtName.Buffer);
    }

    if (CurDirHandle) NtClose(CurDirHandle);

    if (OldHandle) NtClose(OldHandle);

    if (OldCurDirHandle) NtClose(OldCurDirHandle);

    if (OldCurDir && InterlockedDecrement(&OldCurDir->RefCount) == 0)
    {
        NtClose(OldCurDir->Handle);
        RtlFreeHeap(RtlGetProcessHeap(), 0, OldCurDir);
    }

    return Status;
}

/*
 * @implemented
 */
ULONG
NTAPI
RtlGetFullPathName_UEx(
    _In_ PWSTR FileName,
    _In_ ULONG BufferLength,
    _Out_writes_bytes_(BufferLength) PWSTR Buffer,
    _Out_opt_ PWSTR *FilePart,
    _Out_opt_ RTL_PATH_TYPE *InputPathType)
{
    UNICODE_STRING FileNameString;
    NTSTATUS status;

    if (InputPathType)
        *InputPathType = 0;

    /* Build the string */
    status = RtlInitUnicodeStringEx(&FileNameString, FileName);
    if (!NT_SUCCESS(status)) return 0;

    /* Call the extended function */
    return RtlGetFullPathName_Ustr(
        &FileNameString,
        BufferLength,
        Buffer,
        (PCWSTR*)FilePart,
        NULL,
        InputPathType);
}

/******************************************************************
 *    RtlGetFullPathName_U  (NTDLL.@)
 *
 * Returns the number of bytes written to buffer (not including the
 * terminating NULL) if the function succeeds, or the required number of bytes
 * (including the terminating NULL) if the buffer is too small.
 *
 * file_part will point to the filename part inside buffer (except if we use
 * DOS device name, in which case file_in_buf is NULL)
 *
 * @implemented
 */

/*
 * @implemented
 */
ULONG
NTAPI
RtlGetFullPathName_U(
    _In_ PCWSTR FileName,
    _In_ ULONG Size,
    _Out_z_bytecap_(Size) PWSTR Buffer,
    _Out_opt_ PWSTR *ShortName)
{
    RTL_PATH_TYPE PathType;

    /* Call the extended function */
    return RtlGetFullPathName_UEx((PWSTR)FileName,
                                   Size,
                                   Buffer,
                                   ShortName,
                                   &PathType);
}

/*
 * @implemented
 */
BOOLEAN
NTAPI
RtlDosPathNameToNtPathName_U(IN PCWSTR DosName,
                             OUT PUNICODE_STRING NtName,
                             OUT PCWSTR *PartName,
                             OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    /* Call the internal function */
    return NT_SUCCESS(RtlpDosPathNameToRelativeNtPathName_U(FALSE,
                                                            DosName,
                                                            NtName,
                                                            PartName,
                                                            RelativeName));
}

/*
 * @implemented
 */
NTSTATUS
NTAPI
RtlDosPathNameToNtPathName_U_WithStatus(IN PCWSTR DosName,
                                        OUT PUNICODE_STRING NtName,
                                        OUT PCWSTR *PartName,
                                        OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    /* Call the internal function */
    return RtlpDosPathNameToRelativeNtPathName_U(FALSE,
                                                 DosName,
                                                 NtName,
                                                 PartName,
                                                 RelativeName);
}

/*
 * @implemented
 */
BOOLEAN
NTAPI
RtlDosPathNameToRelativeNtPathName_U(IN PCWSTR DosName,
                                     OUT PUNICODE_STRING NtName,
                                     OUT PCWSTR *PartName,
                                     OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    /* Call the internal function */
    ASSERT(RelativeName);
    return NT_SUCCESS(RtlpDosPathNameToRelativeNtPathName_U(TRUE,
                                                            DosName,
                                                            NtName,
                                                            PartName,
                                                            RelativeName));
}

/*
 * @implemented
 */
NTSTATUS
NTAPI
RtlDosPathNameToRelativeNtPathName_U_WithStatus(IN PCWSTR DosName,
                                                OUT PUNICODE_STRING NtName,
                                                OUT PCWSTR *PartName,
                                                OUT PRTL_RELATIVE_NAME_U RelativeName)
{
    /* Call the internal function */
    ASSERT(RelativeName);
    return RtlpDosPathNameToRelativeNtPathName_U(TRUE,
                                                 DosName,
                                                 NtName,
                                                 PartName,
                                                 RelativeName);
}

/*
 * @implemented
 */
NTSTATUS NTAPI RtlNtPathNameToDosPathName(IN ULONG Flags,
                                          IN OUT PRTL_UNICODE_STRING_BUFFER Path,
                                          OUT PULONG PathType,
                                          PULONG Unknown)
{
    PCUNICODE_STRING UsePrefix = NULL, AlternatePrefix = NULL;

    if (PathType)
        *PathType = 0;

    if (!Path || Flags)
        return STATUS_INVALID_PARAMETER;

    /* The initial check is done on Path->String */
    if (RtlPrefixUnicodeString(&RtlpDosDevicesUncPrefix, &Path->String, TRUE))
    {
        UsePrefix = &RtlpDosDevicesUncPrefix;
        AlternatePrefix = &RtlpDoubleSlashPrefix;
        if (PathType)
            *PathType = RTL_CONVERTED_UNC_PATH;
    }
    else if (RtlPrefixUnicodeString(&RtlpDosDevicesPrefix, &Path->String, FALSE))
    {
        UsePrefix = &RtlpDosDevicesPrefix;
        if (PathType)
            *PathType = RTL_CONVERTED_NT_PATH;
    }

    if (UsePrefix)
    {
        NTSTATUS Status;

        USHORT Len = Path->String.Length - UsePrefix->Length;
        if (AlternatePrefix)
            Len += AlternatePrefix->Length;

        Status = RtlEnsureBufferSize(0, &Path->ByteBuffer, Len);
        if (!NT_SUCCESS(Status))
            return Status;

        if (Len + sizeof(UNICODE_NULL) <= Path->ByteBuffer.Size)
        {
            /* Then, the contents of Path->ByteBuffer are always used... */
            if (AlternatePrefix)
            {
                memcpy(Path->ByteBuffer.Buffer, AlternatePrefix->Buffer, AlternatePrefix->Length);
                memmove(Path->ByteBuffer.Buffer + AlternatePrefix->Length, Path->ByteBuffer.Buffer + UsePrefix->Length,
                    Len - AlternatePrefix->Length);
            }
            else
            {
                memmove(Path->ByteBuffer.Buffer, Path->ByteBuffer.Buffer + UsePrefix->Length, Len);
            }
            Path->String.Buffer = (PWSTR)Path->ByteBuffer.Buffer;
            Path->String.Length = Len;
            Path->String.MaximumLength = Path->ByteBuffer.Size;
            Path->String.Buffer[Len / sizeof(WCHAR)] = UNICODE_NULL;
        }
        return STATUS_SUCCESS;
    }

    if (PathType)
    {
        switch (RtlDetermineDosPathNameType_Ustr(&Path->String))
        {
        case RtlPathTypeUncAbsolute:
        case RtlPathTypeDriveAbsolute:
        case RtlPathTypeLocalDevice:
        case RtlPathTypeRootLocalDevice:
            *PathType = RTL_UNCHANGED_DOS_PATH;
            break;
        case RtlPathTypeUnknown:
        case RtlPathTypeDriveRelative:
        case RtlPathTypeRooted:
        case RtlPathTypeRelative:
            *PathType = RTL_UNCHANGED_UNK_PATH;
            break;
        }
    }

    return STATUS_SUCCESS;
}

/*
 * @implemented
 */
ULONG
NTAPI
RtlDosSearchPath_U(IN PCWSTR Path,
                   IN PCWSTR FileName,
                   IN PCWSTR Extension,
                   IN ULONG Size,
                   IN PWSTR Buffer,
                   OUT PWSTR *PartName)
{
    NTSTATUS Status;
    ULONG ExtensionLength, Length, FileNameLength, PathLength;
    UNICODE_STRING TempString;
    PWCHAR NewBuffer, BufferStart;
    PCWSTR p;

    /* Check if this is an absolute path */
    if (RtlDetermineDosPathNameType_U(FileName) != RtlPathTypeRelative)
    {
        /* Check if the file exists */
        if (RtlDoesFileExists_UEx(FileName, TRUE))
        {
            /* Get the full name, which does the DOS lookup */
            return RtlGetFullPathName_U(FileName, Size, Buffer, PartName);
        }

        /* Doesn't exist, so fail */
        return 0;
    }

    /* Scan the filename */
    p = FileName;
    while (*p)
    {
        /* Looking for an extension */
        if (*p == L'.')
        {
            /* No extension string needed -- it's part of the filename */
            Extension = NULL;
            break;
        }

        /* Next character */
        p++;
    }

    /* Do we have an extension? */
    if (!Extension)
    {
        /* Nope, don't worry about one */
        ExtensionLength = 0;
    }
    else
    {
        /* Build a temporary string to get the extension length */
        Status = RtlInitUnicodeStringEx(&TempString, Extension);
        if (!NT_SUCCESS(Status)) return 0;
        ExtensionLength = TempString.Length;
    }

    /* Build a temporary string to get the path length */
    Status = RtlInitUnicodeStringEx(&TempString, Path);
    if (!NT_SUCCESS(Status)) return 0;
    PathLength = TempString.Length;

    /* Build a temporary string to get the filename length */
    Status = RtlInitUnicodeStringEx(&TempString, FileName);
    if (!NT_SUCCESS(Status)) return 0;
    FileNameLength = TempString.Length;

    /* Allocate the buffer for the new string name */
    NewBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
                                0,
                                FileNameLength +
                                ExtensionLength +
                                PathLength +
                                3 * sizeof(WCHAR));
    if (!NewBuffer)
    {
        /* Fail the call */
        DbgPrint("%s: Failing due to out of memory (RtlAllocateHeap failure)\n",
                 __FUNCTION__);
        return 0;
    }

    /* Final loop to build the path */
    while (TRUE)
    {
        /* Check if we have a valid character */
        BufferStart = NewBuffer;
        if (*Path)
        {
            /* Loop as long as there's no semicolon */
            while (*Path != L';')
            {
                /* Copy the next character */
                *BufferStart++ = *Path++;
                if (!*Path) break;
            }

            /* We found a semi-colon, to stop path processing on this loop */
            if (*Path == L';') ++Path;
        }

        /* Add a terminating slash if needed */
        if ((BufferStart != NewBuffer) && (BufferStart[-1] != OBJ_NAME_PATH_SEPARATOR))
        {
            *BufferStart++ = OBJ_NAME_PATH_SEPARATOR;
        }

        /* Bail out if we reached the end */
        if (!*Path) Path = NULL;

        /* Copy the file name and check if an extension is needed */
        RtlCopyMemory(BufferStart, FileName, FileNameLength);
        if (ExtensionLength)
        {
            /* Copy the extension too */
            RtlCopyMemory((PCHAR)BufferStart + FileNameLength,
                          Extension,
                          ExtensionLength + sizeof(WCHAR));
        }
        else
        {
            /* Just NULL-terminate */
            *(PWCHAR)((PCHAR)BufferStart + FileNameLength) = UNICODE_NULL;
        }

        /* Now, does this file exist? */
        if (RtlDoesFileExists_UEx(NewBuffer, FALSE))
        {
            /* Call the full-path API to get the length */
            Length = RtlGetFullPathName_U(NewBuffer, Size, Buffer, PartName);
            break;
        }

        /* If we got here, path doesn't exist, so fail the call */
        Length = 0;
        if (!Path) break;
    }

    /* Free the allocation and return the length */
    RtlFreeHeap(RtlGetProcessHeap(), 0, NewBuffer);
    return Length;
}

/*
 * @implemented
 */
NTSTATUS
NTAPI
RtlGetFullPathName_UstrEx(IN PUNICODE_STRING FileName,
                          IN PUNICODE_STRING StaticString,
                          IN PUNICODE_STRING DynamicString,
                          IN PUNICODE_STRING *StringUsed,
                          IN PSIZE_T FilePartSize,
                          OUT PBOOLEAN NameInvalid,
                          OUT RTL_PATH_TYPE* PathType,
                          OUT PSIZE_T LengthNeeded)
{
    NTSTATUS Status;
    PWCHAR StaticBuffer;
    PCWCH ShortName;
    ULONG Length;
    USHORT StaticLength;
    UNICODE_STRING TempDynamicString;

    /* Initialize all our locals */
    ShortName = NULL;
    StaticBuffer = NULL;
    TempDynamicString.Buffer = NULL;

    /* Initialize the input parameters */
    if (StringUsed) *StringUsed = NULL;
    if (LengthNeeded) *LengthNeeded = 0;
    if (FilePartSize) *FilePartSize = 0;

    /* Check for invalid parameters */
    if ((DynamicString) && !(StringUsed) && (StaticString))
    {
        return STATUS_INVALID_PARAMETER;
    }

    /* Check if we did not get an input string */
    if (!StaticString)
    {
        /* Allocate one */
        StaticLength = MAX_PATH * sizeof(WCHAR);
        StaticBuffer = RtlpAllocateStringMemory(MAX_PATH * sizeof(WCHAR), TAG_USTR);
        if (!StaticBuffer) return STATUS_NO_MEMORY;
    }
    else
    {
        /* Use the one we received */
        StaticBuffer = StaticString->Buffer;
        StaticLength = StaticString->MaximumLength;
    }

    /* Call the lower-level function */
    Length = RtlGetFullPathName_Ustr(FileName,
                                     StaticLength,
                                     StaticBuffer,
                                     &ShortName,
                                     NameInvalid,
                                     PathType);
    DPRINT("Length: %u StaticBuffer: %S\n", Length, StaticBuffer);
    if (!Length)
    {
        /* Fail if it failed */
        DbgPrint("%s(%d) - RtlGetFullPathName_Ustr() returned 0\n",
                 __FUNCTION__,
                 __LINE__);
        Status = STATUS_OBJECT_NAME_INVALID;
        goto Quickie;
    }

    /* Check if it fits inside our static string */
    if ((StaticString) && (Length < StaticLength))
    {
        /* Set the final length */
        StaticString->Length = (USHORT)Length;

        /* Set the file part size */
        if (FilePartSize) *FilePartSize = ShortName ? (ShortName - StaticString->Buffer) : 0;

        /* Return the static string if requested */
        if (StringUsed) *StringUsed = StaticString;

        /* We are done with success */
        Status = STATUS_SUCCESS;
        goto Quickie;
    }

    /* Did we not have an input dynamic string ?*/
    if (!DynamicString)
    {
        /* Return the length we need */
        if (LengthNeeded) *LengthNeeded = Length;

        /* And fail such that the caller can try again */
        Status = STATUS_BUFFER_TOO_SMALL;
        goto Quickie;
    }

    /* Check if it fits in our static buffer */
    if ((StaticBuffer) && (Length < StaticLength))
    {
        /* NULL-terminate it */
        StaticBuffer[Length / sizeof(WCHAR)] = UNICODE_NULL;

        /* Set the settings for the dynamic string the caller sent */
        DynamicString->MaximumLength = StaticLength;
        DynamicString->Length = (USHORT)Length;
        DynamicString->Buffer = StaticBuffer;

        /* Set the part size */
        if (FilePartSize) *FilePartSize = ShortName ? (ShortName - StaticBuffer) : 0;

        /* Return the dynamic string if requested */
        if (StringUsed) *StringUsed = DynamicString;

        /* Do not free the static buffer on exit, and return success */
        StaticBuffer = NULL;
        Status = STATUS_SUCCESS;
        goto Quickie;
    }

    /* Now try again under the PEB lock */
    RtlAcquirePebLock();
    Length = RtlGetFullPathName_Ustr(FileName,
                                     StaticLength,
                                     StaticBuffer,
                                     &ShortName,
                                     NameInvalid,
                                     PathType);
    if (!Length)
    {
        /* It failed */
        DbgPrint("%s line %d: RtlGetFullPathName_Ustr() returned 0\n",
                 __FUNCTION__, __LINE__);
        Status = STATUS_OBJECT_NAME_INVALID;
        goto Release;
    }

    /* Check if it fits inside our static string now */
    if ((StaticString) && (Length < StaticLength))
    {
        /* Set the final length */
        StaticString->Length = (USHORT)Length;

        /* Set the file part size */
        if (FilePartSize) *FilePartSize = ShortName ? (ShortName - StaticString->Buffer) : 0;

        /* Return the static string if requested */
        if (StringUsed) *StringUsed = StaticString;

        /* We are done with success */
        Status = STATUS_SUCCESS;
        goto Release;
    }

    /* Check if the path won't even fit in a real string */
    if ((Length + sizeof(WCHAR)) > UNICODE_STRING_MAX_BYTES)
    {
        /* Name is way too long, fail */
        Status = STATUS_NAME_TOO_LONG;
        goto Release;
    }

    /* Allocate the string to hold the path name now */
    TempDynamicString.Buffer = RtlpAllocateStringMemory(Length + sizeof(WCHAR),
                                                        TAG_USTR);
    if (!TempDynamicString.Buffer)
    {
        /* Out of memory, fail */
        Status = STATUS_NO_MEMORY;
        goto Release;
    }

    /* Add space for a NULL terminator, and now check the full path */
    TempDynamicString.MaximumLength = (USHORT)Length + sizeof(UNICODE_NULL);
    Length = RtlGetFullPathName_Ustr(FileName,
                                     Length,
                                     TempDynamicString.Buffer,
                                     &ShortName,
                                     NameInvalid,
                                     PathType);
    if (!Length)
    {
        /* Some path error, so fail out */
        DbgPrint("%s line %d: RtlGetFullPathName_Ustr() returned 0\n",
                 __FUNCTION__, __LINE__);
        Status = STATUS_OBJECT_NAME_INVALID;
        goto Release;
    }

    /* It should fit in the string we just allocated */
    ASSERT(Length < (TempDynamicString.MaximumLength - sizeof(WCHAR)));
    if (Length > TempDynamicString.MaximumLength)
    {
        /* This is really weird and would mean some kind of race */
        Status = STATUS_INTERNAL_ERROR;
        goto Release;
    }

    /* Return the file part size */
    if (FilePartSize) *FilePartSize = ShortName ? (ShortName - TempDynamicString.Buffer) : 0;

    /* Terminate the whole string now */
    TempDynamicString.Buffer[Length / sizeof(WCHAR)] = UNICODE_NULL;

    /* Finalize the string and return it to the user */
    DynamicString->Buffer = TempDynamicString.Buffer;
    DynamicString->Length = (USHORT)Length;
    DynamicString->MaximumLength = TempDynamicString.MaximumLength;
    if (StringUsed) *StringUsed = DynamicString;

    /* Return success and make sure we don't free the buffer on exit */
    TempDynamicString.Buffer = NULL;
    Status = STATUS_SUCCESS;

Release:
    /* Release the PEB lock */
    RtlReleasePebLock();

Quickie:
    /* Free any buffers we should be freeing */
    DPRINT("Status: %lx %S %S\n", Status, StaticBuffer, TempDynamicString.Buffer);
    if ((StaticString) && (StaticBuffer) && (StaticBuffer != StaticString->Buffer))
    {
        RtlpFreeStringMemory(StaticBuffer, TAG_USTR);
    }
    if (TempDynamicString.Buffer)
    {
        RtlpFreeStringMemory(TempDynamicString.Buffer, TAG_USTR);
    }

    /* Print out any unusual errors */
    if ((NT_ERROR(Status)) &&
        (Status != STATUS_NO_SUCH_FILE) && (Status != STATUS_BUFFER_TOO_SMALL))
    {
        DbgPrint("RTL: %s - failing on filename %wZ with status %08lx\n",
                __FUNCTION__, FileName, Status);
    }

    /* Return, we're all done */
    return Status;
}

/*
 * @implemented
 */
NTSTATUS
NTAPI
RtlDosSearchPath_Ustr(IN ULONG Flags,
                      IN PUNICODE_STRING PathString,
                      IN PUNICODE_STRING FileNameString,
                      IN PUNICODE_STRING ExtensionString,
                      IN PUNICODE_STRING CallerBuffer,
                      IN OUT PUNICODE_STRING DynamicString OPTIONAL,
                      OUT PUNICODE_STRING* FullNameOut OPTIONAL,
                      OUT PSIZE_T FilePartSize OPTIONAL,
                      OUT PSIZE_T LengthNeeded OPTIONAL)
{
    WCHAR StaticCandidateBuffer[MAX_PATH];
    UNICODE_STRING StaticCandidateString;
    NTSTATUS Status;
    RTL_PATH_TYPE PathType;
    PWCHAR p, End, CandidateEnd, SegmentEnd;
    SIZE_T SegmentSize, ByteCount, PathSize, MaxPathSize = 0;
    USHORT NamePlusExtLength, WorstCaseLength, ExtensionLength = 0;
    PUNICODE_STRING FullIsolatedPath;
    DPRINT("DOS Path Search: %lx %wZ %wZ %wZ %wZ %wZ\n",
            Flags, PathString, FileNameString, ExtensionString, CallerBuffer, DynamicString);

    /* Initialize the input string */
    RtlInitEmptyUnicodeString(&StaticCandidateString,
                              StaticCandidateBuffer,
                              sizeof(StaticCandidateBuffer));

    /* Initialize optional arguments */
    if (FullNameOut ) *FullNameOut  = NULL;
    if (FilePartSize) *FilePartSize = 0;
    if (LengthNeeded) *LengthNeeded = 0;
    if (DynamicString)
    {
        DynamicString->Length = DynamicString->MaximumLength = 0;
        DynamicString->Buffer = NULL;
    }

    /* Check for invalid parameters */
    if ((Flags & ~7) ||
        !(PathString) ||
        !(FileNameString) ||
        ((CallerBuffer) && (DynamicString) && !(FullNameOut)))
    {
        /* Fail */
        DbgPrint("%s: Invalid parameters passed\n", __FUNCTION__);
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }

    /* First check what kind of path this is */
    PathType = RtlDetermineDosPathNameType_Ustr(FileNameString);

    /* Check if the caller wants to prevent relative .\ and ..\ paths */
    if ((Flags & 2) &&
         (PathType == RtlPathTypeRelative) &&
         (FileNameString->Length >= (2 * sizeof(WCHAR))) &&
         (FileNameString->Buffer[0] == L'.') &&
         ((IS_PATH_SEPARATOR(FileNameString->Buffer[1])) ||
          ((FileNameString->Buffer[1] == L'.') &&
           ((FileNameString->Length >= (3 * sizeof(WCHAR))) &&
           (IS_PATH_SEPARATOR(FileNameString->Buffer[2]))))))
    {
        /* Yes, and this path is like that, so make it seem unknown */
        PathType = RtlPathTypeUnknown;
    }

    /* Now check relative vs non-relative paths */
    if (PathType == RtlPathTypeRelative)
    {
        /* Does the caller want SxS? */
        if (Flags & 1)
        {
            /* Apply the SxS magic */
            FullIsolatedPath = NULL;
            Status = RtlDosApplyFileIsolationRedirection_Ustr(TRUE,
                                                              FileNameString,
                                                              ExtensionString,
                                                              CallerBuffer,
                                                              DynamicString,
                                                              &FullIsolatedPath,
                                                              NULL,
                                                              FilePartSize,
                                                              LengthNeeded);
            if (NT_SUCCESS(Status))
            {
                /* We found the SxS path, return it */
                if (FullNameOut) *FullNameOut = FullIsolatedPath;
                goto Quickie;
            }
            else if (Status != STATUS_SXS_KEY_NOT_FOUND)
            {
                /* Critical SxS error, fail */
                DbgPrint("%s: Failing because call to "
                         "RtlDosApplyIsolationRedirection_Ustr(%wZ) failed with "
                          "status 0x%08lx\n",
                         __FUNCTION__,
                         FileNameString,
                         Status);
                goto Quickie;
            }
        }

        /* No SxS key found, or not requested, check if there's an extension */
        if (ExtensionString)
        {
            /* Save the extension length, and check if there's a file name */
            ExtensionLength = ExtensionString->Length;
            if (FileNameString->Length)
            {
                /* Start parsing the file name */
                End = &FileNameString->Buffer[FileNameString->Length / sizeof(WCHAR)];
                while (End > FileNameString->Buffer)
                {
                    /* If we find a path separator, there's no extension */
                    if (IS_PATH_SEPARATOR(*--End)) break;

                    /* Otherwise, did we find an extension dot? */
                    if (*End == L'.')
                    {
                        /* Ignore what the caller sent it, use the filename's */
                        ExtensionString = NULL;
                        ExtensionLength = 0;
                        break;
                    }
                }
            }
        }

        /* Check if we got a path */
        if (PathString->Length)
        {
            /* Start parsing the path name, looking for path separators */
            End = &PathString->Buffer[PathString->Length / sizeof(WCHAR)];
            p = End;
            while ((p > PathString->Buffer) && (*--p == L';'))
            {
                /* This is the size of the path -- handle a trailing slash */
                PathSize = End - p - 1;
                if ((PathSize) && !(IS_PATH_SEPARATOR(*(End - 1)))) PathSize++;

                /* Check if we found a bigger path than before */
                if (PathSize > MaxPathSize) MaxPathSize = PathSize;

                /* Keep going with the path after this path separator */
                End = p;
            }

            /* This is the trailing path, run the same code as above */
            PathSize = End - p;
            if ((PathSize) && !(IS_PATH_SEPARATOR(*(End - 1)))) PathSize++;
            if (PathSize > MaxPathSize) MaxPathSize = PathSize;

            /* Finally, convert the largest path size into WCHAR */
            MaxPathSize *= sizeof(WCHAR);
        }

        /* Use the extension, the file name, and the largest path as the size */
        WorstCaseLength = ExtensionLength +
                          FileNameString->Length +
                          (USHORT)MaxPathSize +
                          sizeof(UNICODE_NULL);
        if (WorstCaseLength > UNICODE_STRING_MAX_BYTES)
        {
            /* It has to fit in a registry string, if not, fail here */
            DbgPrint("%s returning STATUS_NAME_TOO_LONG because the computed "
                     "worst case file name length is %Iu bytes\n",
                     __FUNCTION__,
                     WorstCaseLength);
            Status = STATUS_NAME_TOO_LONG;
            goto Quickie;
        }

        /* Scan the path now, to see if we can find the file */
        p = PathString->Buffer;
        End = &p[PathString->Length / sizeof(WCHAR)];
        while (p < End)
        {
            /* Find out where this path ends */
            for (SegmentEnd = p;
                 ((SegmentEnd != End) && (*SegmentEnd != L';'));
                 SegmentEnd++);

            /* Compute the size of this path */
            ByteCount = SegmentSize = (SegmentEnd - p) * sizeof(WCHAR);

            /* Handle trailing slash if there isn't one */
            if ((SegmentSize) && !(IS_PATH_SEPARATOR(*(SegmentEnd - 1))))
            {
                /* Add space for one */
                SegmentSize += sizeof(OBJ_NAME_PATH_SEPARATOR);
            }

            /* Now check if our initial static buffer is too small */
            if (StaticCandidateString.MaximumLength <
                (SegmentSize + ExtensionLength + FileNameString->Length))
            {
                /* At this point we should've been using our static buffer */
                ASSERT(StaticCandidateString.Buffer == StaticCandidateBuffer);
                if (StaticCandidateString.Buffer != StaticCandidateBuffer)
                {
                    /* Something is really messed up if this was the dynamic string */
                    DbgPrint("%s: internal error #1; "
                             "CandidateString.Buffer = %p; "
                             "StaticCandidateBuffer = %p\n",
                            __FUNCTION__,
                            StaticCandidateString.Buffer,
                            StaticCandidateBuffer);
                    Status = STATUS_INTERNAL_ERROR;
                    goto Quickie;
                }

                /* We checked before that the maximum possible size shoudl fit! */
                ASSERT((SegmentSize + FileNameString->Length + ExtensionLength) <
                        UNICODE_STRING_MAX_BYTES);
                if ((SegmentSize + ExtensionLength + FileNameString->Length) >
                    (UNICODE_STRING_MAX_BYTES - sizeof(WCHAR)))
                {
                    /* For some reason it's not fitting anymore. Something messed up */
                    DbgPrint("%s: internal error #2; SegmentSize = %u, "
                             "FileName->Length = %u, DefaultExtensionLength = %u\n",
                             __FUNCTION__,
                             SegmentSize,
                             FileNameString->Length,
                             ExtensionLength);
                    Status = STATUS_INTERNAL_ERROR;
                    goto Quickie;
                }

                /* Now allocate the dynamic string */
                StaticCandidateString.MaximumLength = FileNameString->Length +
                                                      WorstCaseLength;
                StaticCandidateString.Buffer = RtlpAllocateStringMemory(WorstCaseLength,
                                                                        TAG_USTR);
                if (!StaticCandidateString.Buffer)
                {
                    /* Out of memory, fail */
                    DbgPrint("%s: Unable to allocate %u byte buffer for path candidate\n",
                             __FUNCTION__,
                             StaticCandidateString.MaximumLength);
                    Status = STATUS_NO_MEMORY;
                    goto Quickie;
                }
            }

            /* Copy the path in the string */
            RtlCopyMemory(StaticCandidateString.Buffer, p, ByteCount);

            /* Get to the end of the string, and add the trailing slash if missing */
            CandidateEnd = &StaticCandidateString.Buffer[ByteCount / sizeof(WCHAR)];
            if ((SegmentSize) && (SegmentSize != ByteCount))
            {
                *CandidateEnd++ = OBJ_NAME_PATH_SEPARATOR;
            }

            /* Copy the filename now */
            RtlCopyMemory(CandidateEnd,
                          FileNameString->Buffer,
                          FileNameString->Length);
            CandidateEnd += (FileNameString->Length / sizeof(WCHAR));

            /* Check if there was an extension */
            if (ExtensionString)
            {
                /* Copy the extension too */
                RtlCopyMemory(CandidateEnd,
                              ExtensionString->Buffer,
                              ExtensionString->Length);
                          CandidateEnd += (ExtensionString->Length / sizeof(WCHAR));
            }

            /* We are done, terminate it */
            *CandidateEnd = UNICODE_NULL;

            /* Now set the final length of the string so it becomes valid */
            StaticCandidateString.Length = (USHORT)(CandidateEnd -
                                            StaticCandidateString.Buffer) *
                                           sizeof(WCHAR);

            /* Check if this file exists */
            DPRINT("BUFFER: %S\n", StaticCandidateString.Buffer);
            if (RtlDoesFileExists_UEx(StaticCandidateString.Buffer, FALSE))
            {
                /* Awesome, it does, now get the full path */
                Status = RtlGetFullPathName_UstrEx(&StaticCandidateString,
                                                   CallerBuffer,
                                                   DynamicString,
                                                   (PUNICODE_STRING*)FullNameOut,
                                                   FilePartSize,
                                                   NULL,
                                                   &PathType,
                                                   LengthNeeded);
                if (!(NT_SUCCESS(Status)) &&
                    ((Status != STATUS_NO_SUCH_FILE) &&
                     (Status != STATUS_BUFFER_TOO_SMALL)))
                {
                    DbgPrint("%s: Failing because we thought we found %wZ on "
                             "the search path, but RtlGetfullPathNameUStrEx() "
                             "returned %08lx\n",
                             __FUNCTION__,
                             &StaticCandidateString,
                             Status);
                }
                DPRINT("Status: %lx BUFFER: %S\n", Status, CallerBuffer->Buffer);
                goto Quickie;
            }
            else
            {
                /* Otherwise, move to the next path */
                if (SegmentEnd != End)
                {
                    /* Handle the case of the path separator trailing */
                    p = SegmentEnd + 1;
                }
                else
                {
                    p = SegmentEnd;
                }
            }
        }

        /* Loop finished and we didn't break out -- fail */
        Status = STATUS_NO_SUCH_FILE;
    }
    else
    {
        /* We have a full path, so check if it does exist */
        DPRINT("%wZ\n", FileNameString);
        if (!RtlDoesFileExists_UstrEx(FileNameString, TRUE))
        {
            /* It doesn't exist, did we have an extension? */
            if (!(ExtensionString) || !(ExtensionString->Length))
            {
                /* No extension, so just fail */
                Status = STATUS_NO_SUCH_FILE;
                goto Quickie;
            }

            /* There was an extension, check if the filename already had one */
            if (!(Flags & 4) && (FileNameString->Length))
            {
                /* Parse the filename */
                p = FileNameString->Buffer;
                End = &p[FileNameString->Length / sizeof(WCHAR)];
                while (End > p)
                {
                    /* If there's a path separator, there's no extension */
                    if (IS_PATH_SEPARATOR(*--End)) break;

                    /* Othwerwise, did we find an extension dot? */
                    if (*End == L'.')
                    {
                        /* File already had an extension, so fail */
                        Status = STATUS_NO_SUCH_FILE;
                        goto Quickie;
                    }
                }
            }

            /* So there is an extension, we'll try again by adding it */
            NamePlusExtLength = FileNameString->Length +
                                ExtensionString->Length +
                                sizeof(UNICODE_NULL);
            if (NamePlusExtLength > UNICODE_STRING_MAX_BYTES)
            {
                /* It won't fit in any kind of valid string, so fail */
                DbgPrint("%s: Failing because filename plus extension (%Iu bytes) is too big\n",
                         __FUNCTION__,
                         NamePlusExtLength);
                Status = STATUS_NAME_TOO_LONG;
                goto Quickie;
            }

            /* Fill it fit in our temporary string? */
            if (NamePlusExtLength > StaticCandidateString.MaximumLength)
            {
                /* It won't fit anymore, allocate a dynamic string for it */
                StaticCandidateString.MaximumLength = NamePlusExtLength;
                StaticCandidateString.Buffer = RtlpAllocateStringMemory(NamePlusExtLength,
                                                                        TAG_USTR);
                if (!StaticCandidateString.Buffer)
                {
                    /* Ran out of memory, so fail */
                    DbgPrint("%s: Failing because allocating the dynamic filename buffer failed\n",
                             __FUNCTION__);
                    Status = STATUS_NO_MEMORY;
                    goto Quickie;
                }
            }

            /* Copy the filename */
            RtlCopyUnicodeString(&StaticCandidateString, FileNameString);

            /* Copy the extension */
            RtlAppendUnicodeStringToString(&StaticCandidateString,
                                           ExtensionString);

            DPRINT("SB: %wZ\n", &StaticCandidateString);

            /* And check if this file now exists */
            if (!RtlDoesFileExists_UstrEx(&StaticCandidateString, TRUE))
            {
                /* Still no joy, fail out */
                Status = STATUS_NO_SUCH_FILE;
                goto Quickie;
            }

            /* File was found, get the final full path */
            Status = RtlGetFullPathName_UstrEx(&StaticCandidateString,
                                               CallerBuffer,
                                               DynamicString,
                                               (PUNICODE_STRING*)FullNameOut,
                                               FilePartSize,
                                               NULL,
                                               &PathType,
                                               LengthNeeded);
            if (!(NT_SUCCESS(Status)) && (Status != STATUS_NO_SUCH_FILE))
            {
                DbgPrint("%s: Failing on \"%wZ\" because RtlGetfullPathNameUStrEx() "
                         "failed with status %08lx\n",
                         __FUNCTION__,
                         &StaticCandidateString,
                         Status);
            }
            DPRINT("Status: %lx BUFFER: %S\n", Status, CallerBuffer->Buffer);
        }
        else
        {
            /* File was found on the first try, get the final full path */
            Status = RtlGetFullPathName_UstrEx(FileNameString,
                                               CallerBuffer,
                                               DynamicString,
                                               (PUNICODE_STRING*)FullNameOut,
                                               FilePartSize,
                                               NULL,
                                               &PathType,
                                               LengthNeeded);
            if (!(NT_SUCCESS(Status)) &&
                ((Status != STATUS_NO_SUCH_FILE) &&
                (Status != STATUS_BUFFER_TOO_SMALL)))
            {
                DbgPrint("%s: Failing because RtlGetfullPathNameUStrEx() on %wZ "
                         "failed with status %08lx\n",
                         __FUNCTION__,
                         FileNameString,
                         Status);
            }
            DPRINT("Status: %lx BUFFER: %S\n", Status, CallerBuffer->Buffer);
        }
    }

Quickie:
    /* Anything that was not an error, turn into STATUS_SUCCESS */
    if (NT_SUCCESS(Status)) Status = STATUS_SUCCESS;

    /* Check if we had a dynamic string */
    if ((StaticCandidateString.Buffer) &&
        (StaticCandidateString.Buffer != StaticCandidateBuffer))
    {
        /* Free it */
        RtlFreeUnicodeString(&StaticCandidateString);
    }

    /* Return the status */
    return Status;
}

/*
 * @implemented
 */
BOOLEAN
NTAPI
RtlDoesFileExists_U(IN PCWSTR FileName)
{
    /* Call the new function */
    return RtlDoesFileExists_UEx(FileName, TRUE);
}

/* EOF */