da/d66/FsRtlTunnel_8c_source.html

/*

* PROJECT:         ReactOS kernel-mode tests

* LICENSE:         LGPLv2+ - See COPYING.LIB in the top level directory

* PURPOSE:         Kernel-Mode Test Suite FsRtl Test

* PROGRAMMER:      Ashuha Arseny, Moscow State Technical University

*                  Marina Volosnikova, Moscow State Technical University

*                  Denis Petkevich, Moscow State Technical University

*/


#include <kmt_test.h>


#define NDEBUG

#include <debug.h>


/*

Tested with the system kmtest

the following functions:

FsRtlInitializeTunnelCache

FsRtlDeleteTunnelCache

FsRtlAddToTunnelCache

FsRtlDeleteKeyFromTunnelCache

FsRtlFindInTunnelCache

*/


static PTUNNEL T;

static PTUNNEL Tb;


#define BufSize 10000


PUNICODE_STRING CopyUS(PUNICODE_STRING a)

{

    PUNICODE_STRING b = (PUNICODE_STRING)ExAllocatePool(PagedPool,sizeof(UNICODE_STRING));

    ok(b != NULL, "US is NULL after allocated memory\n");

    b->Length = 0;

    b->MaximumLength =a->MaximumLength;

    if (b->MaximumLength)

    {

        b->Buffer = (PWSTR)ExAllocatePoolWithTag(PagedPool, b->MaximumLength, 1633);

        ok(b->Buffer != NULL, "US->Buffer is NULL after allocated memory\n");

        RtlCopyUnicodeString(b, a);

    }

    else

    {

        b->Buffer = NULL;

    }

    return b;

}


void TestFsRtlInitializeTunnelCache()

{

    SIZE_T eq;

    T = ExAllocatePool(PagedPool, sizeof(TUNNEL));

    ok(T != NULL, "PTUNEL is NULL after allocated memory\n");

    Tb = ExAllocatePool(PagedPool, sizeof(TUNNEL));

    ok(Tb != NULL, "PTUNEL is NULL after allocated memory\n");


    memset((void*)T, 0, sizeof(TUNNEL));

    memset((void*)Tb, 0, sizeof(TUNNEL));


    FsRtlInitializeTunnelCache(T);


    eq = RtlCompareMemory((const VOID*)T, (const VOID*)Tb,  sizeof(TUNNEL));


    ok ( eq != sizeof(TUNNEL), "FsRtlInitializeTunnelCache function did not change anything in the memory at the address PTUNEL.\n");

}


void TestFsRtlAddToTunnelCache(ULONGLONG DirectoryKey, PUNICODE_STRING s_name, PUNICODE_STRING l_name, BOOLEAN KeyByShortName)

{

    SIZE_T eq;

    LONG b;

    PUNICODE_STRING bs_name;

    PUNICODE_STRING bl_name;

    PVOID Bufb;

    PVOID Buf;


    Buf = ExAllocatePool(PagedPool, BufSize);

    ok(Buf != NULL, "Buff in TestFsRtlAddToTunnelCache is NULL after allocated memory\n");

    Bufb = ExAllocatePool(PagedPool, BufSize);

    ok(Bufb != NULL, "Buff in TestFsRtlAddToTunnelCache is NULL after allocated memory\n");


    // Allocate memory for the  bufs_name

    bs_name = CopyUS(s_name);


    // Allocate memory for the l_name and bl_name

    bl_name = CopyUS(l_name);


    memset((void*)Buf, 0, BufSize);

    memset((void*)Bufb, 0, BufSize);


    FsRtlAddToTunnelCache(T, DirectoryKey, s_name, l_name, KeyByShortName, BufSize, Buf);


    eq = RtlCompareMemory((const VOID*)Buf, (const VOID*)Bufb,  BufSize);


    ok( eq !=  sizeof(TUNNEL),"FsRtlAddToTunnelCache function did not change anything in the memory at the address Buf.\n");


    b = RtlCompareUnicodeString(l_name, bl_name, TRUE);

    ok (b == 0, "long name after call FsRtlAddToTunnelCache != long name befo call FsRtlAddToTunnelCache\n\n");

    b = RtlCompareUnicodeString(s_name, bs_name, TRUE);

    ok (b == 0, "short name after call FsRtlAddToTunnelCache != short name befo call FsRtlAddToTunnelCache\n\n");


    if (bs_name->Buffer) ExFreePool(bs_name->Buffer);

    ExFreePool(bs_name);

    if (bl_name->Buffer) ExFreePool(bl_name->Buffer);

    ExFreePool(bl_name);

    ExFreePool(Bufb);

    ExFreePool(Buf);

}


BOOLEAN TestFsRtlFindInTunnelCache(ULONG DirectoryKey, PUNICODE_STRING name, PUNICODE_STRING s_name, PUNICODE_STRING l_name)

{

    // Allocate memory for the Buf

    ULONG BufsizeTemp = BufSize;

    PVOID Buf = ExAllocatePool(PagedPool, BufSize*2);

    ok(Buf != NULL, "Buff in FsRtlFindInTunnelCache is NULL after allocated memory\n");


    return FsRtlFindInTunnelCache(T, DirectoryKey, name, s_name, l_name, &BufsizeTemp, Buf);

}


void TestFsRtlDeleteKeyFromTunnelCache(ULONGLONG a)

{

    FsRtlDeleteKeyFromTunnelCache(T, a);

}


static

void DuplicatesTest()

{

    UNICODE_STRING ShortName, LongName, OutShort, OutLong, ShortName2, LongName2;

    ULONG First, Second, OutLength, OutData;

    PTUNNEL Tunnel;

    PVOID Buffer;


    First = 1;

    Second = 2;

    RtlInitUnicodeString(&ShortName, L"LONGFI~1.TXT");

    RtlInitUnicodeString(&LongName, L"Longfilename.txt");

    RtlInitUnicodeString(&ShortName2, L"LONGFI~2.TXT");

    RtlInitUnicodeString(&LongName2, L"Longfilenamr.txt");

    Tunnel = ExAllocatePool(NonPagedPool, sizeof(TUNNEL));

    RtlZeroMemory(Tunnel, sizeof(TUNNEL));

    OutShort.MaximumLength = 13 * sizeof(WCHAR);

    OutShort.Buffer = ExAllocatePool(PagedPool, OutShort.MaximumLength);

    OutLong.MaximumLength = 17 * sizeof(WCHAR);

    OutLong.Buffer = Buffer = ExAllocatePool(PagedPool, OutLong.MaximumLength);


    FsRtlInitializeTunnelCache(Tunnel);

    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName, &LongName, TRUE, sizeof(ULONG), &First);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "First call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 1);

    ok_eq_pointer(OutLong.Buffer, Buffer);


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName, &LongName, TRUE, sizeof(ULONG), &Second);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Second call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);

    ok_eq_pointer(OutLong.Buffer, Buffer);


    OutLong.MaximumLength = 13 * sizeof(WCHAR);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Third call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);

    ok(OutLong.Buffer != Buffer, "Buffer didn't get reallocated!\n");

    ok_eq_uint(OutLong.MaximumLength, 16 * sizeof(WCHAR));


    FsRtlDeleteKeyFromTunnelCache(Tunnel, 1);

    ok_bool_false(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Fourth call");


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName, &LongName, TRUE, sizeof(ULONG), &First);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Fifth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 1);


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName2, &LongName2, TRUE, sizeof(ULONG), &First);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Sixth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 1);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName2, &OutShort, &OutLong, &OutLength, &OutData), "Seventh call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 1);


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName, &LongName, TRUE, sizeof(ULONG), &Second);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Eighth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName2, &OutShort, &OutLong, &OutLength, &OutData), "Ninth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 1);


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName2, &LongName2, TRUE, sizeof(ULONG), &Second);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Tenth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName2, &OutShort, &OutLong, &OutLength, &OutData), "Eleventh call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);


    FsRtlDeleteKeyFromTunnelCache(Tunnel, 1);

    ok_bool_false(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Twelfth call");

    ok_bool_false(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName2, &OutShort, &OutLong, &OutLength, &OutData), "Thirteenth call");


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName, &LongName, TRUE, sizeof(ULONG), &First);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Fourteenth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 1);


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName, &LongName, TRUE, sizeof(ULONG), &Second);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Fifteenth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName2, &LongName2, TRUE, sizeof(ULONG), &First);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Sixteenth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName2, &OutShort, &OutLong, &OutLength, &OutData), "Seventeenth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 1);


    FsRtlAddToTunnelCache(Tunnel, 1, &ShortName2, &LongName2, TRUE, sizeof(ULONG), &Second);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName, &OutShort, &OutLong, &OutLength, &OutData), "Eighteenth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);

    ok_bool_true(FsRtlFindInTunnelCache(Tunnel, 1, &ShortName2, &OutShort, &OutLong, &OutLength, &OutData), "Nineteenth call");

    ok_eq_ulong(OutLength, sizeof(ULONG));

    ok_eq_ulong(OutData, 2);


    FsRtlDeleteTunnelCache(Tunnel);

    ExFreePool(OutShort.Buffer);

    ExFreePool(OutLong.Buffer);

    ExFreePool(Buffer);

    ExFreePool(Tunnel);

}


START_TEST(FsRtlTunnel)

{

    UNICODE_STRING s_name;

    UNICODE_STRING l_name;

    UNICODE_STRING name;

    UNICODE_STRING a;

    BOOLEAN is;


    //Initialize Cash

    TestFsRtlInitializeTunnelCache();


    s_name.Length = 0;

    s_name.MaximumLength = 64 * sizeof(WCHAR);

    s_name.Buffer = ExAllocatePoolWithTag(PagedPool, s_name.MaximumLength, 'sFmK');

    ok(s_name.Buffer != NULL, "s_name.Buffer in TestFsRtlAddToTunnelCache is NULL after allocated memory\n");

    RtlAppendUnicodeToString(&s_name, L"smal");


    l_name.Length = 0;

    l_name.MaximumLength = 64 * sizeof(WCHAR);

    l_name.Buffer = ExAllocatePoolWithTag(PagedPool, l_name.MaximumLength, 'lFmK');

    ok(l_name.Buffer != NULL, "l_name.Buffer in TestFsRtlAddToTunnelCache is NULL after allocated memory\n");

    RtlAppendUnicodeToString(&l_name, L"bigbigbigbigbig");


    // Add elem

    TestFsRtlAddToTunnelCache(12345, &s_name, &l_name, TRUE);


    name.Length = 0;

    name.MaximumLength = 64 * sizeof(WCHAR);

    name.Buffer = ExAllocatePoolWithTag(PagedPool, name.MaximumLength, 'nFmK');

    ok(name.Buffer != NULL, "name.Buffer in FsRtlFindInTunnelCache is NULL after allocated memory\n");

    RtlAppendUnicodeToString(&name, L"smal");


    // Find

    is = TestFsRtlFindInTunnelCache(12345, &name, &s_name, &l_name);

    ok(is == TRUE, "FsRtlFindInTunnelCache dosn't find elem id = 12345\n");


    TestFsRtlDeleteKeyFromTunnelCache(12345);   //Delete

    is = TestFsRtlFindInTunnelCache(12345, &name, &s_name, &l_name);

    ok(is == FALSE, "TestFsRtlDeleteKeyFromTunnelCache dosn't delete elem id = 12345\n");


    is = TestFsRtlFindInTunnelCache(12347, &name, &s_name, &l_name);

    ok(is == FALSE, "FsRtlDeleteTunnelCache dosn't clear cash\n");


    TestFsRtlAddToTunnelCache(12345, &s_name, &l_name, TRUE);

    TestFsRtlAddToTunnelCache(12347, &s_name, &l_name, TRUE);

    RtlInitUnicodeString(&a, NULL);

    TestFsRtlAddToTunnelCache(12346, &a, &l_name, FALSE);


    //Clear all

    FsRtlDeleteTunnelCache(T);


    is = TestFsRtlFindInTunnelCache(12345, &name, &s_name, &l_name);

    ok(is == FALSE, "FsRtlDeleteTunnelCache dosn't clear cash\n");


    is = TestFsRtlFindInTunnelCache(12346, &name, &a, &l_name);

    ok(is == FALSE, "FsRtlDeleteTunnelCache dosn't clear cash\n");


    is = TestFsRtlFindInTunnelCache(12347, &name, &s_name, &l_name);

    ok(is == FALSE, "FsRtlDeleteTunnelCache dosn't clear cash\n");


    ExFreePoolWithTag(name.Buffer, 'nFmK');

    ExFreePoolWithTag(l_name.Buffer, 'lFmK');

    ExFreePoolWithTag(s_name.Buffer, 'sFmK');


    ExFreePool(Tb);

    ExFreePool(T);


    DuplicatesTest();

}

Second
WCHAR Second[]
Definition: FormatMessage.c:12

First
WCHAR First[]
Definition: FormatMessage.c:11

TestFsRtlInitializeTunnelCache
void TestFsRtlInitializeTunnelCache()
Definition: FsRtlTunnel.c:49

CopyUS
PUNICODE_STRING CopyUS(PUNICODE_STRING a)
Definition: FsRtlTunnel.c:30

TestFsRtlAddToTunnelCache
void TestFsRtlAddToTunnelCache(ULONGLONG DirectoryKey, PUNICODE_STRING s_name, PUNICODE_STRING l_name, BOOLEAN KeyByShortName)
Definition: FsRtlTunnel.c:67

TestFsRtlFindInTunnelCache
BOOLEAN TestFsRtlFindInTunnelCache(ULONG DirectoryKey, PUNICODE_STRING name, PUNICODE_STRING s_name, PUNICODE_STRING l_name)
Definition: FsRtlTunnel.c:109

Tb
static PTUNNEL Tb
Definition: FsRtlTunnel.c:26

BufSize
#define BufSize
Definition: FsRtlTunnel.c:28

T
static PTUNNEL T
Definition: FsRtlTunnel.c:25

DuplicatesTest
static void DuplicatesTest()
Definition: FsRtlTunnel.c:125

TestFsRtlDeleteKeyFromTunnelCache
void TestFsRtlDeleteKeyFromTunnelCache(ULONGLONG a)
Definition: FsRtlTunnel.c:119

BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185

s_name
static const CHAR s_name[]
Definition: ShowWindow.c:19

ok_eq_pointer
#define ok_eq_pointer(value, expected)
Definition: apitest.h:40

ok_eq_ulong
#define ok_eq_ulong(value, expected)
Definition: apitest.h:44

ok_bool_false
#define ok_bool_false(value, desc)
Definition: apitest.h:60

ok_eq_uint
#define ok_eq_uint(value, expected)
Definition: apitest.h:42

ok_bool_true
#define ok_bool_true(value, desc)
Definition: apitest.h:59

ok
#define ok(value,...)
Definition: atltest.h:57

START_TEST
#define START_TEST(x)
Definition: atltest.h:75

Buffer
Definition: bufpool.h:45

NULL
#define NULL
Definition: types.h:112

TRUE
#define TRUE
Definition: types.h:120

FALSE
#define FALSE
Definition: types.h:117

PUNICODE_STRING
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373

ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350

RtlCompareUnicodeString
ULONG RtlCompareUnicodeString(PUNICODE_STRING s1, PUNICODE_STRING s2, BOOLEAN UpCase)
Definition: string_lib.cpp:31

RtlCompareMemory
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465

RtlAppendUnicodeToString
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62

ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352

NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307

PagedPool
#define PagedPool
Definition: env_spec_w32.h:308

ShortName
IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING ShortName
Definition: fatprocs.h:1307

ExAllocatePool
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44

LongName
_In_ ULONGLONG _In_ PUNICODE_STRING _In_ PUNICODE_STRING LongName
Definition: fsrtlfuncs.h:338

DirectoryKey
_In_ ULONGLONG DirectoryKey
Definition: fsrtlfuncs.h:336

KeyByShortName
_In_ ULONGLONG _In_ PUNICODE_STRING _In_ PUNICODE_STRING _In_ BOOLEAN KeyByShortName
Definition: fsrtlfuncs.h:339

b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204

a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

void
Definition: nsiface.idl:2307

a
#define a
Definition: ke_i.h:78

b
#define b
Definition: ke_i.h:79

kmt_test.h

ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109

eq
#define eq(received, expected, label, type)
Definition: locale.c:144

RtlCopyUnicodeString
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)

RtlInitUnicodeString
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)

L
#define L(x)
Definition: ntvdm.h:50

LONG
long LONG
Definition: pedump.c:60

memset
#define memset(x, y, z)
Definition: compat.h:39

_TUNNEL
Definition: fsrtltypes.h:213

_UNICODE_STRING
Definition: env_spec_w32.h:368

_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369

_UNICODE_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:370

_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371

name
Definition: name.c:39

FsRtlInitializeTunnelCache
VOID NTAPI FsRtlInitializeTunnelCache(IN PTUNNEL Cache)
Definition: tunnel.c:892

FsRtlAddToTunnelCache
VOID NTAPI FsRtlAddToTunnelCache(IN PTUNNEL Cache, IN ULONGLONG DirectoryKey, IN PUNICODE_STRING ShortName, IN PUNICODE_STRING LongName, IN BOOLEAN KeyByShortName, IN ULONG DataLength, IN PVOID Data)
Definition: tunnel.c:342

FsRtlFindInTunnelCache
BOOLEAN NTAPI FsRtlFindInTunnelCache(IN PTUNNEL Cache, IN ULONGLONG DirectoryKey, IN PUNICODE_STRING Name, OUT PUNICODE_STRING ShortName, OUT PUNICODE_STRING LongName, IN OUT PULONG DataLength, OUT PVOID Data)
Definition: tunnel.c:766

FsRtlDeleteTunnelCache
VOID NTAPI FsRtlDeleteTunnelCache(IN PTUNNEL Cache)
Definition: tunnel.c:691

FsRtlDeleteKeyFromTunnelCache
VOID NTAPI FsRtlDeleteKeyFromTunnelCache(IN PTUNNEL Cache, IN ULONGLONG DirectoryKey)
Definition: tunnel.c:589

PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56

SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80

RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

ULONG
uint32_t ULONG
Definition: typedefs.h:59

ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67

WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180