fltmgr_register.c

Go to the documentation of this file.

/*
 * PROJECT:         ReactOS kernel-mode tests - Filter Manager
 * LICENSE:         GPLv2+ - See COPYING in the top level directory
 * PURPOSE:         Tests for checking filter registration
 * PROGRAMMER:      Ged Murphy <gedmurphy@reactos.org>
 */
 
// This tests needs to be run via a standalone driver because FltRegisterFilter
// uses the DriverObject in its internal structures, and we don't want it to be
// linked to a device object from the test suite itself.
 
#include <kmt_test.h>
#include <fltkernel.h>
#include <fltmgrint.h>
 
//#define NDEBUG
#include <debug.h>
 
#define RESET_REGISTRATION(basic) \
    do { \
        RtlZeroMemory(&FilterRegistration, sizeof(FLT_REGISTRATION)); \
        if (basic) { \
            FilterRegistration.Size = sizeof(FLT_REGISTRATION); \
            FilterRegistration.Version = FLT_REGISTRATION_VERSION; \
        } \
    } while (0)
 
#define RESET_UNLOAD(DO) DO->DriverUnload = NULL;
 
 
NTSTATUS
FLTAPI
TestRegFilterUnload(
    _In_ FLT_FILTER_UNLOAD_FLAGS Flags
);
 
/* Globals */
static PDRIVER_OBJECT TestDriverObject;
static FLT_REGISTRATION FilterRegistration;
static PFLT_FILTER TestFilter = NULL;
 
 
 
 
BOOLEAN
TestFltRegisterFilter(_In_ PDRIVER_OBJECT DriverObject)
{
    UNICODE_STRING Altitude;
    UNICODE_STRING Name;
    PFLT_FILTER Filter = NULL;
    PFLT_FILTER Temp = NULL;
    NTSTATUS Status;
 
    RESET_REGISTRATION(FALSE);
#if 0
    KmtStartSeh()
        Status = FltRegisterFilter(NULL, &FilterRegistration, &Filter);
    KmtEndSeh(STATUS_INVALID_PARAMETER);
 
    KmtStartSeh()
        Status = FltRegisterFilter(DriverObject, NULL, &Filter);
    KmtEndSeh(STATUS_INVALID_PARAMETER);
 
    KmtStartSeh()
        Status = FltRegisterFilter(DriverObject, &FilterRegistration, NULL);
    KmtEndSeh(STATUS_INVALID_PARAMETER)
#endif
 
    RESET_REGISTRATION(TRUE);
    FilterRegistration.Version = 0x0100;
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &Filter);
    ok_eq_hex(Status, STATUS_INVALID_PARAMETER);
 
    RESET_REGISTRATION(TRUE);
    FilterRegistration.Version = 0x0300;
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &Filter);
    ok_eq_hex(Status, STATUS_INVALID_PARAMETER);
 
    RESET_REGISTRATION(TRUE);
    FilterRegistration.Version = 0x0200;
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &Filter);
    ok_eq_hex(Status, STATUS_SUCCESS);
    FltUnregisterFilter(Filter);
 
 
    /* Test invalid sizes. MSDN says this is required, but it doesn't appear to be */
    RESET_REGISTRATION(TRUE);
    FilterRegistration.Size = 0;
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &Filter);
    ok_eq_hex(Status, STATUS_SUCCESS);
    FltUnregisterFilter(Filter);
 
    RESET_REGISTRATION(TRUE);
    FilterRegistration.Size = 0xFFFF;
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &Filter);
    ok_eq_hex(Status, STATUS_SUCCESS);
    FltUnregisterFilter(Filter);
 
 
    /* Now make a valid registration */
    RESET_REGISTRATION(TRUE);
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &Filter);
    ok_eq_hex(Status, STATUS_SUCCESS);
 
    /* Try to register again */
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &Temp);
    ok_eq_hex(Status, STATUS_FLT_INSTANCE_ALTITUDE_COLLISION);
 
 
    ok_eq_hex(Filter->Base.Flags, FLT_OBFL_TYPE_FILTER);
 
    /* Check we have the right filter name */
    RtlInitUnicodeString(&Name, L"Kmtest-FltMgrReg");
    ok_eq_long(RtlCompareUnicodeString(&Filter->Name, &Name, FALSE), 0);
 
    /* And the altitude is corect */
    RtlInitUnicodeString(&Altitude, L"123456");
    ok_eq_long(RtlCompareUnicodeString(&Filter->DefaultAltitude, &Altitude, FALSE), 0);
 
    //
    // FIXME: More checks
    //
 
    /* Cleanup the valid registration */
    FltUnregisterFilter(Filter);
 
    /*
     * The last thing we'll do before we exit is to properly register with the filter manager
     * and set an unload routine. This'll let us test the FltUnregisterFilter routine
     */
    RESET_REGISTRATION(TRUE);
 
    /* Set a fake unload routine we'll use to test */
    DriverObject->DriverUnload = (PDRIVER_UNLOAD)0x1234FFFF;
 
    FilterRegistration.FilterUnloadCallback = TestRegFilterUnload;
    Status = FltRegisterFilter(DriverObject, &FilterRegistration, &TestFilter);
    ok_eq_hex(Status, STATUS_SUCCESS);
 
    /* Test all the unlod routines */
    ok_eq_pointer(TestFilter->FilterUnload, TestRegFilterUnload);
    ok_eq_pointer(TestFilter->OldDriverUnload, (PFLT_FILTER_UNLOAD_CALLBACK)0x1234FFFF);
 
    // This should equal the fltmgr's private unload routine, but there's no easy way of testing it...
    //ok_eq_pointer(DriverObject->DriverUnload, FltpMiniFilterDriverUnload);
 
    /* Make sure our test address is never actually called */
    TestFilter->OldDriverUnload = (PFLT_FILTER_UNLOAD_CALLBACK)NULL;
 
    return TRUE;
}
 
 
NTSTATUS
FLTAPI
TestRegFilterUnload(
    _In_ FLT_FILTER_UNLOAD_FLAGS Flags)
{
    //__debugbreak();
 
    ok_irql(PASSIVE_LEVEL);
    ok(TestFilter != NULL, "Buffer is NULL\n");
 
    //
    // FIXME: Add tests
    //
 
    FltUnregisterFilter(TestFilter);
 
    //
    // FIXME: Add tests
    //
 
    return STATUS_SUCCESS;
}
 
 
 
 
 
 
 
 
 
 
/*
 * KMT Callback routines
 */
 
NTSTATUS
TestEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PCUNICODE_STRING RegistryPath,
    OUT PCWSTR *DeviceName,
    IN OUT INT *Flags)
{
    NTSTATUS Status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(RegistryPath);
 
    DPRINT("FltMgrReg Entry!\n");
    trace("Entered FltMgrReg tests\n");
 
    /* We'll do the work ourselves in this test */
    *Flags = TESTENTRY_NO_ALL;
 
    ok_irql(PASSIVE_LEVEL);
    TestDriverObject = DriverObject;
 
 
    /* Run the tests */
    (VOID)TestFltRegisterFilter(DriverObject);
 
    return Status;
}
 
VOID
TestFilterUnload(
    IN ULONG Flags)
{
    PAGED_CODE();
    ok_irql(PASSIVE_LEVEL);
}
 
NTSTATUS
TestInstanceSetup(
    _In_ PCFLT_RELATED_OBJECTS FltObjects,
    _In_ FLT_INSTANCE_SETUP_FLAGS Flags,
    _In_ DEVICE_TYPE VolumeDeviceType,
    _In_ FLT_FILESYSTEM_TYPE VolumeFilesystemType,
    _In_ PUNICODE_STRING VolumeName,
    _In_ ULONG SectorSize,
    _In_ ULONG ReportedSectorSize
)
{
    return STATUS_FLT_DO_NOT_ATTACH;
}
 
VOID
TestQueryTeardown(
    _In_ PCFLT_RELATED_OBJECTS FltObjects,
    _In_ FLT_INSTANCE_QUERY_TEARDOWN_FLAGS Flags)
{
    UNREFERENCED_PARAMETER(FltObjects);
    UNREFERENCED_PARAMETER(Flags);
}