RtlNtPathNameToDosPathName.c File Reference

#include "precomp.h"

Include dependency graph for RtlNtPathNameToDosPathName.c:

Go to the source code of this file.

Classes
struct	test_entry

Macros
#define	ok_hex2(expression, result)
#define	ok_ptr2(expression, result)
#define	ok_wstr2(x, y)    winetest_ok(wcscmp(x, y) == 0, "Wrong string. Expected '%S', got '%S'\n", y, x)

Functions
	NTSTATUS (NTAPI *pRtlNtPathNameToDosPathName)(ULONG Flags
static void	test_specialhandling ()
static void	test_table (struct test_entry *Entry)
	START_TEST (RtlNtPathNameToDosPathName)

Variables
PRTL_UNICODE_STRING_BUFFER	Path
PRTL_UNICODE_STRING_BUFFER PULONG	Type
PRTL_UNICODE_STRING_BUFFER PULONG PULONG	Unknown4
static struct test_entry	test_data []

Macro Definition Documentation

ok_hex2

#define ok_hex2	(		expression,
			result
	)

Value:

    do { \
        int _value = (expression); \
        winetest_ok(_value == (result), "Wrong value for '%s', expected: " #result " (0x%x), got: 0x%x\n", \
           #expression, (int)(result), _value); \
    } while (0)

Definition at line 12 of file RtlNtPathNameToDosPathName.c.

ok_ptr2

#define ok_ptr2	(		expression,
			result
	)

Value:

    do { \
        void *_value = (expression); \
        winetest_ok(_value == (result), "Wrong value for '%s', expected: " #result " (%p), got: %p\n", \
           #expression, (void*)(result), _value); \
    } while (0)

Definition at line 20 of file RtlNtPathNameToDosPathName.c.

ok_wstr2

#define ok_wstr2	(		x,
			y
	)		winetest_ok(wcscmp(x, y) == 0, "Wrong string. Expected '%S', got '%S'\n", y, x)

Definition at line 27 of file RtlNtPathNameToDosPathName.c.

Function Documentation

NTSTATUS()

NTSTATUS

(

NTAPI *

pRtlNtPathNameToDosPathName

)

START_TEST()

START_TEST

(

RtlNtPathNameToDosPathName

)

Definition at line 403 of file RtlNtPathNameToDosPathName.c.

{
    RTL_UNICODE_STRING_BUFFER Buffer = { { 0 } };
    ULONG Type;
    size_t n;
 
    HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
    pRtlNtPathNameToDosPathName = (void *)GetProcAddress(ntdll, "RtlNtPathNameToDosPathName");
 
    if (!pRtlNtPathNameToDosPathName)
    {
        skip("RtlNtPathNameToDosPathName not found?\n");
        return;
    }
 
    ok_ntstatus(pRtlNtPathNameToDosPathName(0, NULL, NULL, NULL), STATUS_INVALID_PARAMETER);
    ok_ntstatus(pRtlNtPathNameToDosPathName(0, &Buffer, NULL, NULL), STATUS_SUCCESS);
    ok_ntstatus(pRtlNtPathNameToDosPathName(1, &Buffer, NULL, NULL), STATUS_INVALID_PARAMETER);
 
    Type = 0x12345;
    ok_ntstatus(pRtlNtPathNameToDosPathName(0, NULL, &Type, NULL), STATUS_INVALID_PARAMETER);
    ok_int(Type, 0);
    Type = 0x12345;
    ok_ntstatus(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
    ok_int(Type, RTL_UNCHANGED_UNK_PATH);
    Type = 0x12345;
    ok_ntstatus(pRtlNtPathNameToDosPathName(1, &Buffer, &Type, NULL), STATUS_INVALID_PARAMETER);
    ok_int(Type, 0);
 
    test_specialhandling();
 
    for (n = 0; n < _countof(test_data); ++n)
    {
        winetest_set_location(test_data[n].File, test_data[n].Line);
        test_table(test_data + n);
    }
}

test_specialhandling()

static void test_specialhandling ( )

static

Definition at line 234 of file RtlNtPathNameToDosPathName.c.

{
    RTL_UNICODE_STRING_BUFFER Buffer;
    const WCHAR TestString[] = L"\\??\\C:\\Test";
    WCHAR StaticBuffer[_countof(TestString)];
    ULONG Type;
    //PUCHAR Ptr;
 
    /* Just initializing the ByteBuffer does not work */
    memset(&Buffer, 0, sizeof(Buffer));
    RtlInitBuffer(&Buffer.ByteBuffer, (PUCHAR)StaticBuffer, sizeof(StaticBuffer));
    memcpy(StaticBuffer, TestString, sizeof(TestString));
    Type = 0x12345;
 
    ok_hex(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
    ok_hex(Type, RTL_UNCHANGED_UNK_PATH);
    ok_ptr(Buffer.String.Buffer, NULL);
    ok_int(Buffer.String.Length, 0);
    ok_int(Buffer.String.MaximumLength, 0);
    ok_ptr(Buffer.ByteBuffer.Buffer, Buffer.ByteBuffer.StaticBuffer);
    ok_int(Buffer.ByteBuffer.Size, Buffer.ByteBuffer.StaticSize);
    RtlFreeBuffer(&Buffer.ByteBuffer);
 
    /* Different strings in the String and ByteBuffer part */
    memset(&Buffer, 0, sizeof(Buffer));
    RtlInitBuffer(&Buffer.ByteBuffer, (PUCHAR)StaticBuffer, sizeof(StaticBuffer));
    memcpy(StaticBuffer, TestString, sizeof(TestString));
    Type = 0x12345;
 
    RtlInitUnicodeString(&Buffer.String, L"\\??\\D:\\1234");
 
    ok_hex(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
    ok_hex(Type, RTL_CONVERTED_NT_PATH);
    ok_wstr(Buffer.String.Buffer, L"C:\\Test");
    ok_int(Buffer.String.Length, 14);
    ok_int(Buffer.String.MaximumLength, 24);
    ok_ptr(Buffer.ByteBuffer.Buffer, Buffer.ByteBuffer.StaticBuffer);
    ok_int(Buffer.ByteBuffer.Size, Buffer.ByteBuffer.StaticSize);
    RtlFreeBuffer(&Buffer.ByteBuffer);
 
 
    /* Different strings, Buffer.String is not prefixed with \??\ */
    memset(&Buffer, 0, sizeof(Buffer));
    RtlInitBuffer(&Buffer.ByteBuffer, (PUCHAR)StaticBuffer, sizeof(StaticBuffer));
    memcpy(StaticBuffer, TestString, sizeof(TestString));
    Type = 0x12345;
 
    RtlInitUnicodeString(&Buffer.String, L"D:\\1234");
 
    ok_hex(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
    ok_hex(Type, RTL_UNCHANGED_DOS_PATH);
    ok_wstr(Buffer.String.Buffer, L"D:\\1234");
    ok_int(Buffer.String.Length, 14);
    ok_int(Buffer.String.MaximumLength, 16);
    ok_ptr(Buffer.ByteBuffer.Buffer, Buffer.ByteBuffer.StaticBuffer);
    ok_int(Buffer.ByteBuffer.Size, Buffer.ByteBuffer.StaticSize);
    RtlFreeBuffer(&Buffer.ByteBuffer);
 
 
    /* Different strings, smaller ByteBuffer */
    memset(&Buffer, 0, sizeof(Buffer));
    RtlInitBuffer(&Buffer.ByteBuffer, (PUCHAR)StaticBuffer, sizeof(StaticBuffer));
    memcpy(StaticBuffer, TestString, sizeof(TestString));
    Type = 0x12345;
 
    RtlInitUnicodeString(&Buffer.String, L"\\??\\D:\\1234");
    Buffer.ByteBuffer.Size -= 4 * sizeof(WCHAR);
 
    ok_hex(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
    ok_hex(Type, RTL_CONVERTED_NT_PATH);
    ok_wstr(Buffer.String.Buffer, L"C:\\Test");
    ok_int(Buffer.String.Length, 14);
    ok_ptr(Buffer.ByteBuffer.Buffer, Buffer.ByteBuffer.StaticBuffer);
    ok_int(Buffer.ByteBuffer.Size, Buffer.ByteBuffer.StaticSize - 4 * sizeof(WCHAR));
    RtlFreeBuffer(&Buffer.ByteBuffer);
 
 
    /* These tests show that the size of the ByteBuffer should
        at least equal the size of the string (minus 4, in case of \??\‍)!
        The results are all over the place, and are most likely the result of implementation details.. */
 
#if 0
    /* Different strings, too small ByteBuffer
        --> corrupt buffer, but none of the output params suggests so? */
    memset(&Buffer, 0, sizeof(Buffer));
    Buffer.ByteBuffer.Size = wcslen(TestString) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
    Buffer.ByteBuffer.Buffer = Ptr = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, Buffer.ByteBuffer.Size);
    memcpy(Buffer.ByteBuffer.Buffer, TestString, Buffer.ByteBuffer.Size);
    Type = 0x12345;
 
    RtlInitUnicodeString(&Buffer.String, L"\\??\\D:\\1234");
    Buffer.ByteBuffer.Size -= 5 * sizeof(WCHAR);
 
    ok_hex(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
    ok_hex(Type, RTL_CONVERTED_NT_PATH);
    //ok_wstr(Buffer.String.Buffer, L"C:\\");
    ok_int(Buffer.String.Length, 14);
    ok_int(Buffer.String.MaximumLength, 16);
    //ok_ptr(Buffer.ByteBuffer.Buffer, Ptr);    // An attempt is made at allocating a buffer, but the move fails because the size of ByteBuffer seems to be used??
    ok_int(Buffer.ByteBuffer.Size, 16);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer.ByteBuffer.Buffer);
 
    /* Different strings, too small ByteBuffer, different path separators
        --> corrupt buffer, but none of the output params suggests so? */
    memset(&Buffer, 0, sizeof(Buffer));
    Buffer.ByteBuffer.Size = wcslen(L"\\??\\C://Test") * sizeof(WCHAR) + sizeof(UNICODE_NULL);
    Buffer.ByteBuffer.Buffer = Ptr = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, Buffer.ByteBuffer.Size);
    memcpy(Buffer.ByteBuffer.Buffer, L"\\??\\C://Test", Buffer.ByteBuffer.Size);
    Type = 0x12345;
 
    RtlInitUnicodeString(&Buffer.String, L"\\??\\D:\\1234");
    Buffer.ByteBuffer.Size -= 5 * sizeof(WCHAR);
 
    ok_hex(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
    ok_hex(Type, RTL_CONVERTED_NT_PATH);
    //ok_wstr(Buffer.String.Buffer, L"C:\\");
    ok_int(Buffer.String.Length, 14);
    ok_int(Buffer.String.MaximumLength, 16);
    ok_ptr(Buffer.ByteBuffer.Buffer, Ptr);
    ok_int(Buffer.ByteBuffer.Size, 16);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer.ByteBuffer.Buffer);
#endif
}

Referenced by START_TEST().

test_table()

static void test_table ( struct test_entry *  Entry )

static

Definition at line 360 of file RtlNtPathNameToDosPathName.c.

{
    RTL_UNICODE_STRING_BUFFER Buffer = { { 0 } };
    WCHAR StaticBuffer[MAX_PATH];
    ULONG Type = 0x12345;
 
    RtlInitBuffer(&Buffer.ByteBuffer, (PUCHAR)StaticBuffer, sizeof(StaticBuffer));
 
    RtlInitUnicodeString(&Buffer.String, Entry->InputPath);
    RtlEnsureBufferSize(RTL_SKIP_BUFFER_COPY, &Buffer.ByteBuffer, Buffer.String.MaximumLength);
    memcpy(Buffer.ByteBuffer.Buffer, Buffer.String.Buffer, Buffer.String.MaximumLength);
 
    ok_hex2(pRtlNtPathNameToDosPathName(0, &Buffer, &Type, NULL), STATUS_SUCCESS);
 
    ok_hex2(Type, Entry->Type);
    ok_wstr2(Buffer.String.Buffer, Entry->OutputPath);
    /* If there is no change in the path, the pointer is unchanged */
    if (!wcscmp(Entry->InputPath, Entry->OutputPath))
    {
        ok_ptr2(Buffer.String.Buffer, Entry->InputPath);
    }
    else
    {
        /* If there is a change in the path, the 'ByteBuffer' is used */
        winetest_ok((PUCHAR)Buffer.String.Buffer >= Buffer.ByteBuffer.StaticBuffer &&
                    (PUCHAR)Buffer.String.Buffer <= (Buffer.ByteBuffer.StaticBuffer + Buffer.ByteBuffer.StaticSize),
                    "Expected Buffer to point inside StaticBuffer\n");
    }
    ok_wstr2((const WCHAR *)Buffer.ByteBuffer.Buffer, Entry->OutputPath);
 
    ok_hex2(Buffer.MinimumStaticBufferForTerminalNul, 0);
 
    /* For none of our tests should we exceed the StaticBuffer size! */
    ok_ptr2(Buffer.ByteBuffer.Buffer, Buffer.ByteBuffer.StaticBuffer);
    ok_hex2(Buffer.ByteBuffer.Size, Buffer.ByteBuffer.StaticSize);
 
    ok_hex2(Buffer.ByteBuffer.ReservedForAllocatedSize, 0);
    ok_ptr2(Buffer.ByteBuffer.ReservedForIMalloc, NULL);
 
    RtlFreeBuffer(&Buffer.ByteBuffer);
}

Referenced by START_TEST().

Variable Documentation

Path

PRTL_UNICODE_STRING_BUFFER Path

Definition at line 10 of file RtlNtPathNameToDosPathName.c.

test_data

struct test_entry test_data[]

static

Definition at line 43 of file RtlNtPathNameToDosPathName.c.

Type

PRTL_UNICODE_STRING_BUFFER PULONG Type

Definition at line 10 of file RtlNtPathNameToDosPathName.c.

Referenced by START_TEST(), and test_specialhandling().

Unknown4

PRTL_UNICODE_STRING_BUFFER PULONG PULONG Unknown4

Definition at line 10 of file RtlNtPathNameToDosPathName.c.

Referenced by BaseQueryModuleData(), DhcpEnumClasses(), DllRegisterServer(), NtUserCreateWindowStation(), and CStartMenuSite::Unknown().