#include "precomp.h"

Include dependency graph for RtlNtPathNameToDosPathName.c:

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);
}