vfwmi.с Source Code

/*++

Copyright (c) none


Module Name:

    vfwmi.с

Abstract:

    This module contains verifying System Control IRPs are handled correctly.

--*/

#include "vfdef.h"

#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, VfWmiInit)
#pragma alloc_text(PAGEVRFY, VfWmiVerifyNewRequest)
#pragma alloc_text(PAGEVRFY, VfWmiVerifyIrpStackDownward)
#pragma alloc_text(PAGEVRFY, VfWmiVerifyIrpStackUpward)
#pragma alloc_text(PAGEVRFY, VfWmiDumpIrpStack)
#pragma alloc_text(PAGEVRFY, VfWmiTestStartedPdoStack)
#endif

#ifdef ALLOC_DATA_PRAGMA
#pragma data_seg("PAGEVRFC")
#pragma const_seg("PAGEVRFC")
#endif

VOID
VfWmiInit(
    VOID
    )
{
    VfMajorRegisterHandlers(
        IRP_MJ_SYSTEM_CONTROL,
        VfWmiDumpIrpStack,
        VfWmiVerifyNewRequest,
        VfWmiVerifyIrpStackDownward,
        VfWmiVerifyIrpStackUpward,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        VfWmiTestStartedPdoStack,
        NULL
        );
}

VOID
FASTCALL
VfWmiVerifyNewRequest(
    IN PIOV_REQUEST_PACKET  IovPacket,
    IN PDEVICE_OBJECT       DeviceObject,
    IN PIO_STACK_LOCATION   IrpLastSp           OPTIONAL,
    IN PIO_STACK_LOCATION   IrpSp,
    IN PIOV_STACK_LOCATION  StackLocationData,
    IN PVOID                CallerAddress       OPTIONAL
    )
{
    NTSTATUS status;

    status = IovPacket->TrackedIrp->IoStatus.Status;
    if ( status != STATUS_NOT_SUPPORTED )
    {
        WDM_FAIL_ROUTINE((
            DCERROR_WMI_IRP_BAD_INITIAL_STATUS,
            DCPARAM_IRP + DCPARAM_ROUTINE,
            CallerAddress,
            &IovPacket->TrackedIrp->Type
            ));

        if ( status < STATUS_SUCCESS )
        {
            StackLocationData->Flags |= STACKFLAG_FAILURE_FORWARDED;
        }
    }
}

VOID
FASTCALL
VfWmiVerifyIrpStackDownward(
    IN PIOV_REQUEST_PACKET  IovPacket,
    IN PDEVICE_OBJECT       DeviceObject,
    IN PIO_STACK_LOCATION   IrpLastSp                   OPTIONAL,
    IN PIO_STACK_LOCATION   IrpSp,
    IN PIOV_STACK_LOCATION  RequestHeadLocationData,
    IN PIOV_STACK_LOCATION  StackLocationData,
    IN PVOID                CallerAddress               OPTIONAL
    )
{
    PIRP Irp;
    PDRIVER_OBJECT DriverObject;

//    PIOV_REQUEST_PACKET headPacket;
//    headPacket = IovPacket->HeadPacket;
//    ASSERT((headPacket->pIovSessionData == NULL)|| (IovPacket->Flags&TRACKFLAG_ACTIVE));

    Irp = IovPacket->TrackedIrp;
    if ( VfPacketGetCurrentSessionData(IovPacket)->ForwardMethod == SKIPPED_A_DO && IovpInitCalled )
    {
        VfBugcheckThrowIoException(
            DCERROR_SKIPPED_DEVICE_OBJECT,
            DCPARAM_IRP + DCPARAM_ROUTINE,
            CallerAddress,
            Irp
            );
    }

    DriverObject = DeviceObject->DriverObject;
    if ( !IovUtilHasDispatchHandler(DriverObject, IRP_MJ_SYSTEM_CONTROL) )
    {
        RequestHeadLocationData->Flags |= STACKFLAG_BOGUS_IRP_TOUCHED;
        WDM_FAIL_ROUTINE((
            DCERROR_MISSING_DISPATCH_FUNCTION,
            DCPARAM_IRP + DCPARAM_ROUTINE,
            DriverObject->DriverInit,
            Irp
            ));
        StackLocationData->Flags |= STACKFLAG_NO_HANDLER;
    }
}

VOID
FASTCALL
VfWmiVerifyIrpStackUpward(
    IN PIOV_REQUEST_PACKET  IovPacket,
    IN PIO_STACK_LOCATION   IrpSp,
    IN PIOV_STACK_LOCATION  RequestHeadLocationData,
    IN PIOV_STACK_LOCATION  StackLocationData,
    IN BOOLEAN              IsNewlyCompleted,
    IN BOOLEAN              RequestFinalized
    )
{
    PIRP Irp;
    PVOID routine;

    Irp = IovPacket->TrackedIrp;
    routine = StackLocationData->LastDispatch;

    ASSERT(routine);
    if ( IsNewlyCompleted
        && ~(StackLocationData->Flags >> 28) & ~(StackLocationData->Flags >> 31) & ((PDEVICE_OBJECT)IrpSp->Parameters.WMI.ProviderId != IrpSp->DeviceObject) & 1 )
    {
        if ( IovpInitCalled )
        {
            WDM_FAIL_ROUTINE((
                DCERROR_WMI_IRP_NOT_FORWARDED,
                DCPARAM_IRP + DCPARAM_ROUTINE + DCPARAM_DEVOBJ,
                routine,
                Irp
            ));
        }
    }
}

PCHAR WmiIrpNames[] = {
    "IRP_MN_QUERY_ALL_DATA",                  // 0x00
    "IRP_MN_QUERY_SINGLE_INSTANCE",           // 0x01
    "IRP_MN_CHANGE_SINGLE_INSTANCE",          // 0x02
    "IRP_MN_CHANGE_SINGLE_ITEM",              // 0x03
    "IRP_MN_ENABLE_EVENTS",                   // 0x04
    "IRP_MN_DISABLE_EVENTS",                  // 0x05
    "IRP_MN_ENABLE_COLLECTION",               // 0x06
    "IRP_MN_DISABLE_COLLECTION",              // 0x07
    "IRP_MN_REGINFO",                         // 0x08
    "IRP_MN_EXECUTE_METHOD",                  // 0x09
    NULL
    };

#define MAX_NAMED_WMI_IRP   0x9

VOID
FASTCALL
VfWmiDumpIrpStack(
    IN PIO_STACK_LOCATION IrpSp
    )
{
    DbgPrint("IRP_MJ_SYSTEM_CONTROL.");

    if ( IrpSp->MinorFunction <= MAX_NAMED_WMI_IRP )
    {
        DbgPrint(WmiIrpNames[IrpSp->MinorFunction]);
    }
    else if ( IrpSp->MinorFunction == 0xFF )
    {
        DbgPrint("IRP_MN_BOGUS");
    }
    else
    {
        DbgPrint("(Bogus)");
    }
}

VOID
FASTCALL
VfWmiTestStartedPdoStack(
    IN PDEVICE_OBJECT   PhysicalDeviceObject
    )
{
    IO_STACK_LOCATION irpSp;

    PAGED_CODE();

    *&irpSp.MajorFunction = IRP_MJ_CREATE;
    irpSp.Parameters.WMI.ProviderId = 0i64;
    irpSp.Parameters.QueryDirectory.FileName = 0i64;
    irpSp.Parameters.Read.ByteOffset.QuadPart = 0i64;
    irpSp.Parameters.CreatePipe.Parameters = 0i64;
    irpSp.DeviceObject = 0i64;
    irpSp.FileObject = 0i64;
    irpSp.CompletionRoutine = 0i64;
    irpSp.Context = 0i64;

    if ( VfSettingsIsOptionEnabled(NULL, VERIFIER_OPTION_SEND_BOGUS_WMI_IRPS) )
    {
        irpSp.MajorFunction = IRP_MJ_SYSTEM_CONTROL;
        irpSp.MinorFunction = 0xFFu;
        irpSp.Parameters.WMI.ProviderId = (ULONG_PTR) PhysicalDeviceObject;
        VfIrpSendSynchronousIrp(
            PhysicalDeviceObject,
            &irpSp,
            TRUE,
            STATUS_NOT_SUPPORTED,
            (ULONG_PTR) NULL,
            (ULONG_PTR) NULL,
            NULL
            );
    }
}

#ifdef ALLOC_DATA_PRAGMA
#pragma data_seg()
#pragma const_seg()
#endif