wmidrv.c File Reference

#include <ntoskrnl.h>
#include <wmistr.h>
#include <wmiioctl.h>
#include "wmip.h"
#include <debug.h>

Include dependency graph for wmidrv.c:

Go to the source code of this file.

Classes
struct	_WMIP_REGISTER_GUIDS
struct	_WMIP_RESULT
struct	_WMI_UNREGISTER_GUID
struct	_WMI_GUID_OBJECT_ENTRY
struct	_WMI_NOTIFICATION
struct	_WMI_SET_MARK
struct	_WMI_OPEN_GUID_FOR_EVENTS
struct	_WMIP_RESULT2

Macros
#define	NDEBUG

Typedefs
typedef struct _WMIP_REGISTER_GUIDS	WMIP_REGISTER_GUIDS
typedef struct _WMIP_REGISTER_GUIDS *	PWMIP_REGISTER_GUIDS
typedef struct _WMIP_RESULT	WMIP_RESULT
typedef struct _WMIP_RESULT *	PWMIP_RESULT
typedef struct _WMI_UNREGISTER_GUID	WMI_UNREGISTER_GUID
typedef struct _WMI_UNREGISTER_GUID *	PWMI_UNREGISTER_GUID
typedef struct _WMI_GUID_OBJECT_ENTRY	WMI_GUID_OBJECT_ENTRY
typedef struct _WMI_GUID_OBJECT_ENTRY *	PWMI_GUID_OBJECT_ENTRY
typedef struct _WMI_NOTIFICATION	WMI_NOTIFICATION
typedef struct _WMI_NOTIFICATION *	PWMI_NOTIFICATION
typedef struct _WMI_SET_MARK	WMI_SET_MARK
typedef struct _WMI_SET_MARK *	PWMI_SET_MARK
typedef struct _WMI_OPEN_GUID_FOR_EVENTS	WMI_OPEN_GUID_FOR_EVENTS
typedef struct _WMI_OPEN_GUID_FOR_EVENTS *	PWMI_OPEN_GUID_FOR_EVENTS
typedef struct _WMIP_RESULT2	WMIP_RESULT2
typedef struct _WMIP_RESULT2 *	PWMIP_RESULT2

Functions
NTSTATUS NTAPI	WmipOpenCloseCleanup (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
static NTSTATUS	WmiTraceEvent (PVOID InputBuffer, KPROCESSOR_MODE PreviousMode)
static NTSTATUS	WmiTraceUserMessage (PVOID InputBuffer, ULONG InputBufferLength)
static NTSTATUS	WmipCaptureGuidObjectAttributes (_In_ POBJECT_ATTRIBUTES GuidObjectAttributes, _Out_ POBJECT_ATTRIBUTES CapuredObjectAttributes, _Out_ PUNICODE_STRING CapturedObjectName, _Out_ PWSTR ObjectNameBuffer, _In_ KPROCESSOR_MODE AccessMode)
static NTSTATUS	WmipRegisterGuids (_In_ PDEVICE_OBJECT DeviceObject, _In_ PVOID Buffer, _In_ ULONG InputLength, _Inout_ PULONG OutputLength)
static NTSTATUS	WmipUnregisterGuids (_In_ PVOID Buffer, _In_ ULONG InputLength, _Inout_ PULONG OutputLength)
VOID NTAPI	WmipClearIrpObjectList (_In_ PIRP Irp)
VOID NTAPI	WmipNotificationIrpCancel (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
static VOID	WmipInitializeIrpContext (PWMIP_IRP_CONTEXT IrpContext)
static NTSTATUS	WmipReceiveNotifications (_Inout_ PIRP Irp, _In_ PVOID Buffer, _In_ ULONG InputLength, _Inout_ PULONG OutputLength)
static NTSTATUS	WmipOpenGuidForEvents (PVOID Buffer, ULONG InputLength, PULONG OutputLength)
static NTSTATUS	WmiSetMark (PWMI_SET_MARK Buffer, ULONG Length)
NTSTATUS NTAPI	WmipIoControl (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
NTSTATUS NTAPI	WmipSystemControl (_Inout_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
NTSTATUS NTAPI	WmipShutdown (_Inout_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
	_Function_class_ (FAST_IO_DEVICE_CONTROL)
NTSTATUS NTAPI	WmipDockUndockEventCallback (_In_ PVOID NotificationStructure, _Inout_opt_ PVOID Context)
	_Function_class_ (DRIVER_INITIALIZE)

Variables
PDEVICE_OBJECT	WmipServiceDeviceObject
PDEVICE_OBJECT	WmipAdminDeviceObject
FAST_IO_DISPATCH	WmipFastIoDispatch
DRIVER_DISPATCH	WmipOpenCloseCleanup
DRIVER_DISPATCH	WmipIoControl
DRIVER_DISPATCH	WmipSystemControl
DRIVER_DISPATCH	WmipShutdown

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 16 of file wmidrv.c.

Typedef Documentation

PWMI_GUID_OBJECT_ENTRY

typedef struct _WMI_GUID_OBJECT_ENTRY * PWMI_GUID_OBJECT_ENTRY

PWMI_NOTIFICATION

typedef struct _WMI_NOTIFICATION * PWMI_NOTIFICATION

PWMI_OPEN_GUID_FOR_EVENTS

typedef struct _WMI_OPEN_GUID_FOR_EVENTS * PWMI_OPEN_GUID_FOR_EVENTS

PWMI_SET_MARK

typedef struct _WMI_SET_MARK * PWMI_SET_MARK

PWMI_UNREGISTER_GUID

typedef struct _WMI_UNREGISTER_GUID * PWMI_UNREGISTER_GUID

PWMIP_REGISTER_GUIDS

typedef struct _WMIP_REGISTER_GUIDS * PWMIP_REGISTER_GUIDS

PWMIP_RESULT

typedef struct _WMIP_RESULT * PWMIP_RESULT

PWMIP_RESULT2

typedef struct _WMIP_RESULT2 * PWMIP_RESULT2

WMI_GUID_OBJECT_ENTRY

typedef struct _WMI_GUID_OBJECT_ENTRY WMI_GUID_OBJECT_ENTRY

WMI_NOTIFICATION

typedef struct _WMI_NOTIFICATION WMI_NOTIFICATION

WMI_OPEN_GUID_FOR_EVENTS

typedef struct _WMI_OPEN_GUID_FOR_EVENTS WMI_OPEN_GUID_FOR_EVENTS

WMI_SET_MARK

typedef struct _WMI_SET_MARK WMI_SET_MARK

WMI_UNREGISTER_GUID

typedef struct _WMI_UNREGISTER_GUID WMI_UNREGISTER_GUID

WMIP_REGISTER_GUIDS

typedef struct _WMIP_REGISTER_GUIDS WMIP_REGISTER_GUIDS

WMIP_RESULT

typedef struct _WMIP_RESULT WMIP_RESULT

WMIP_RESULT2

typedef struct _WMIP_RESULT2 WMIP_RESULT2

Function Documentation

_Function_class_() [1/2]

_Function_class_

(

DRIVER_INITIALIZE

)

Definition at line 614 of file wmidrv.c.

{
    static UNICODE_STRING ServiceDeviceName = RTL_CONSTANT_STRING(L"\\Device\\WMIDataDevice");
    static UNICODE_STRING ServiceDosDeviceName = RTL_CONSTANT_STRING(L"\\DosDevices\\WMIDataDevice");
    static UNICODE_STRING AdminDeviceName = RTL_CONSTANT_STRING(L"\\Device\\WMIAdminDevice");
    static UNICODE_STRING AdminDosDeviceName = RTL_CONSTANT_STRING(L"\\DosDevices\\WMIAdminDevice");
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Create the service device object */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &ServiceDeviceName,
                            FILE_DEVICE_UNKNOWN,
                            FILE_DEVICE_SECURE_OPEN,
                            0,
                            &WmipServiceDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create service device: 0x%lx\n", Status);
        return Status;
    }
 
    /* Create a symbolic link for the service device */
    Status = IoCreateSymbolicLink(&ServiceDosDeviceName, &ServiceDeviceName);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateSymbolicLink() failed: 0x%lx\n", Status);
        IoDeleteDevice(WmipServiceDeviceObject);
        return Status;
    }
 
    /* Create the admin device object */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &AdminDeviceName,
                            FILE_DEVICE_UNKNOWN,
                            FILE_DEVICE_SECURE_OPEN,
                            0,
                            &WmipAdminDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create admin device: 0x%lx\n", Status);
        IoDeleteDevice(WmipServiceDeviceObject);
        IoDeleteSymbolicLink(&ServiceDosDeviceName);
        return Status;
    }
 
    /* Create a symbolic link for the admin device */
    Status = IoCreateSymbolicLink(&AdminDosDeviceName, &AdminDeviceName);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateSymbolicLink() failed: 0x%lx\n", Status);
        IoDeleteSymbolicLink(&ServiceDosDeviceName);
        IoDeleteDevice(WmipServiceDeviceObject);
        IoDeleteDevice(WmipAdminDeviceObject);
        return Status;
    }
 
    /* Initialize dispatch routines */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = WmipOpenCloseCleanup;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = WmipOpenCloseCleanup;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = WmipIoControl;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = WmipOpenCloseCleanup;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = WmipSystemControl;
    DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = WmipShutdown;
 
    /* Initialize fast dispatch */
    RtlZeroMemory(&WmipFastIoDispatch, sizeof(WmipFastIoDispatch));
    WmipFastIoDispatch.SizeOfFastIoDispatch = sizeof(WmipFastIoDispatch);
    WmipFastIoDispatch.FastIoDeviceControl = WmipFastIoDeviceControl;
    DriverObject->FastIoDispatch = &WmipFastIoDispatch;
 
    /* Register the WMI service device */
    IoWMIRegistrationControl(WmipServiceDeviceObject, WMIREG_ACTION_REGISTER);
 
    /* Register a shutdown notification */
    IoRegisterShutdownNotification(WmipServiceDeviceObject);
 
    /* Initialization is done */
    WmipServiceDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
    WmipAdminDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
    return STATUS_SUCCESS;
}

_Function_class_() [2/2]

_Function_class_

(

FAST_IO_DEVICE_CONTROL

)

Definition at line 560 of file wmidrv.c.

{
    PAGED_CODE();
 
    if (IoControlCode == IOCTL_WMI_TRACE_EVENT)
    {
        if (InputBufferLength < 0x30)
        {
            DPRINT1("Buffer too small\n");
            return FALSE;
        }
 
        IoStatus->Status = WmiTraceEvent(InputBuffer, ExGetPreviousMode());
        return TRUE;
    }
    else if (IoControlCode == IOCTL_WMI_TRACE_USER_MESSAGE)
    {
        if (InputBufferLength < 0x30)
        {
            DPRINT1("Buffer too small\n");
            return FALSE;
        }
 
        IoStatus->Status = WmiTraceUserMessage(InputBuffer, InputBufferLength);
        return TRUE;
    }
 
    DPRINT1("Invalid io control code for fast dispatch: 0x%lx\n", IoControlCode);
    return FALSE;
}

WmipCaptureGuidObjectAttributes()

static NTSTATUS WmipCaptureGuidObjectAttributes ( _In_ POBJECT_ATTRIBUTES  GuidObjectAttributes, _Out_ POBJECT_ATTRIBUTES  CapuredObjectAttributes, _Out_ PUNICODE_STRING  CapturedObjectName, _Out_ PWSTR  ObjectNameBuffer, _In_ KPROCESSOR_MODE  AccessMode  )

static

Definition at line 121 of file wmidrv.c.

{
    ASSERT(AccessMode != KernelMode);
 
    _SEH2_TRY
    {
        /* Probe and copy the object attributes structure */
        ProbeForRead(GuidObjectAttributes,
                     sizeof(OBJECT_ATTRIBUTES),
                     sizeof(PVOID));
        *CapuredObjectAttributes = *GuidObjectAttributes;
 
        /* Probe and copy the object name UNICODE_STRING */
        ProbeForRead(CapuredObjectAttributes->ObjectName,
                     sizeof(UNICODE_STRING),
                     sizeof(PVOID));
        *CapturedObjectName = *CapuredObjectAttributes->ObjectName;
 
        /* Check if the object name has the expected length */
        if (CapturedObjectName->Length != 45 * sizeof(WCHAR))
        {
            _SEH2_YIELD(return STATUS_INVALID_PARAMETER);
        }
 
        /* Probe and copy the object name buffer */
        ProbeForRead(CapturedObjectName->Buffer,
                     CapturedObjectName->Length,
                     sizeof(WCHAR));
        RtlCopyMemory(ObjectNameBuffer,
                      CapturedObjectName->Buffer,
                      CapturedObjectName->Length);
 
        /* Fix pointers */
        CapturedObjectName->Buffer = ObjectNameBuffer;
        GuidObjectAttributes->ObjectName = CapturedObjectName;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        DPRINT1("Got exception!\n");
        _SEH2_YIELD(return _SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    return STATUS_SUCCESS;
}

Referenced by WmipOpenGuidForEvents(), and WmipRegisterGuids().

WmipClearIrpObjectList()

VOID NTAPI WmipClearIrpObjectList

(

_In_ PIRP

Irp

)

Definition at line 255 of file wmidrv.c.

{
    PWMIP_IRP_CONTEXT IrpContext;
    PLIST_ENTRY ListEntry;
    PWMIP_GUID_OBJECT GuidObject;
 
    /* Get the IRP context */
    IrpContext = (PWMIP_IRP_CONTEXT)Irp->Tail.Overlay.DriverContext;
 
    /* Loop all GUID objects attached to this IRP */
    for (ListEntry = IrpContext->GuidObjectListHead.Flink;
         ListEntry != &IrpContext->GuidObjectListHead;
         ListEntry = ListEntry->Flink)
    {
        /* Get the GUID object */
        GuidObject = CONTAINING_RECORD(ListEntry, WMIP_GUID_OBJECT, IrpLink);
 
        /* Make sure the IRP matches and clear it */
        ASSERT(GuidObject->Irp == Irp);
        GuidObject->Irp = NULL;
 
        /* Remove the entry */
        RemoveEntryList(ListEntry);
    }
}

Referenced by WmipNotificationIrpCancel().

WmipDockUndockEventCallback()

NTSTATUS NTAPI WmipDockUndockEventCallback	(	_In_ PVOID	NotificationStructure,
		_Inout_opt_ PVOID	Context
	)

Definition at line 606 of file wmidrv.c.

{
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

WmipInitializeIrpContext()

static VOID WmipInitializeIrpContext ( PWMIP_IRP_CONTEXT  IrpContext )

static

Definition at line 302 of file wmidrv.c.

{
    /* Initialize the list head for GUID objects */
    InitializeListHead(&IrpContext->GuidObjectListHead);
}

Referenced by WmipReceiveNotifications().

WmipIoControl()

NTSTATUS NTAPI WmipIoControl	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 448 of file wmidrv.c.

{
    PIO_STACK_LOCATION IoStackLocation;
    ULONG IoControlCode;
    PVOID Buffer;
    ULONG InputLength, OutputLength;
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Get the current stack location */
    IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
 
    /* Get the io control parameters */
    IoControlCode = IoStackLocation->Parameters.DeviceIoControl.IoControlCode;
    Buffer = Irp->AssociatedIrp.SystemBuffer;
    InputLength = IoStackLocation->Parameters.DeviceIoControl.InputBufferLength;
    OutputLength = IoStackLocation->Parameters.DeviceIoControl.OutputBufferLength;
 
    switch (IoControlCode)
    {
 
        case IOCTL_WMI_REGISTER_GUIDS:
        {
            Status = WmipRegisterGuids(DeviceObject,
                                       Buffer,
                                       InputLength,
                                       &OutputLength);
            break;
        }
 
        case IOCTL_WMI_UNREGISTER_GUIDS:
        {
            Status = WmipUnregisterGuids(Buffer,
                                         InputLength,
                                         &OutputLength);
            break;
        }
 
        case IOCTL_WMI_RECEIVE_NOTIFICATIONS:
        {
            Status = WmipReceiveNotifications(Irp,
                                              Buffer,
                                              InputLength,
                                              &OutputLength);
            break;
        }
 
        case 0x228168:
        {
            DPRINT1("IOCTL 0x228168 is unimplemented, ignoring\n");
            Status = STATUS_SUCCESS;
            break;
        }
 
        case IOCTL_WMI_OPEN_GUID_FOR_EVENTS:
        {
            Status = WmipOpenGuidForEvents(Buffer, InputLength, &OutputLength);
            break;
        }
 
        case IOCTL_WMI_SET_MARK:
        {
            if (InputLength < FIELD_OFFSET(WMI_SET_MARK, Mark))
            {
                Status = STATUS_UNSUCCESSFUL;
                break;
            }
 
            Status = WmiSetMark(Buffer, InputLength);
            break;
        }
 
        default:
            DPRINT1("Unsupported yet IOCTL: 0x%lx\n", IoControlCode);
            Status = STATUS_INVALID_DEVICE_REQUEST;
            __debugbreak();
            break;
    }
 
    if (Status == STATUS_PENDING)
        return Status;
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = NT_SUCCESS(Status) ? OutputLength : 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

WmipNotificationIrpCancel()

VOID NTAPI WmipNotificationIrpCancel	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 284 of file wmidrv.c.

{
    /* Clear the list */
    WmipClearIrpObjectList(Irp);
 
    /* Release the cancel spin lock */
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    /* Set the status to cancelled and complete the IRP */
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by WmipReceiveNotifications().

WmipOpenCloseCleanup()

NTSTATUS NTAPI WmipOpenCloseCleanup	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 86 of file wmidrv.c.

{
    PAGED_CODE();
 
    /* No work to do, just return success */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

WmipOpenGuidForEvents()

static NTSTATUS WmipOpenGuidForEvents ( PVOID  Buffer, ULONG  InputLength, PULONG  OutputLength  )

static

Definition at line 383 of file wmidrv.c.

{
    PWMI_OPEN_GUID_FOR_EVENTS OpenGuidForEvents = Buffer;
    PWMIP_RESULT2 Result = (PWMIP_RESULT2)Buffer;
    OBJECT_ATTRIBUTES LocalObjectAttributes;
    UNICODE_STRING LocalObjectName;
    WCHAR LocalObjectNameBuffer[45 + 1];
    KPROCESSOR_MODE PreviousMode;
    HANDLE GuidObjectHandle;
    PVOID GuidObject;
    NTSTATUS Status;
 
    if ((InputLength != sizeof(WMI_OPEN_GUID_FOR_EVENTS)) ||
        (*OutputLength != sizeof(WMIP_RESULT2)))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Capture object attributes */
    PreviousMode = ExGetPreviousMode();
    Status = WmipCaptureGuidObjectAttributes(OpenGuidForEvents->ObjectAttributes,
                                             &LocalObjectAttributes,
                                             &LocalObjectName,
                                             LocalObjectNameBuffer,
                                             PreviousMode);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ProbeAndCaptureGuidObjectAttributes failed: 0x%lx\n", Status);
        return Status;
    }
 
    /* Open a new GUID object */
    Status = WmipOpenGuidObjectByName(&LocalObjectAttributes,
                                      OpenGuidForEvents->DesiredAccess,
                                      PreviousMode,
                                      &GuidObjectHandle,
                                      &GuidObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("WmipOpenGuidObjectByName failed: 0x%lx\n", Status);
        return Status;
    }
 
    Result->Handle = GuidObjectHandle;
 
    ObDereferenceObject(GuidObject);
 
    return STATUS_SUCCESS;
}

Referenced by WmipIoControl().

WmipReceiveNotifications()

static NTSTATUS WmipReceiveNotifications ( _Inout_ PIRP  Irp, _In_ PVOID  Buffer, _In_ ULONG  InputLength, _Inout_ PULONG  OutputLength  )

static

FIXME: For now we don't do any actual work, but simply pretend we are waiting for notifications. We won't ever deliver any though.

Definition at line 311 of file wmidrv.c.

{
    PWMI_NOTIFICATION Notification;
    PWMIP_IRP_CONTEXT IrpContext;
    NTSTATUS Status;
 
    //__debugbreak();
    if ((InputLength < sizeof(WMI_NOTIFICATION)) || (*OutputLength < 0x38))
    {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    Notification = (PWMI_NOTIFICATION)Buffer;
    DBG_UNREFERENCED_LOCAL_VARIABLE(Notification);
 
    // loop all objects
        // reference the object
            // on failure, fail the whole request
 
    // loop all objects
        // update the irp (synchronization!)
            // if we had one before complete the old irp with an error
 
    /* Get the IRP context and initialize it */
    IrpContext = (PWMIP_IRP_CONTEXT)Irp->Tail.Overlay.DriverContext;
    WmipInitializeIrpContext(IrpContext);
 
    // loop all objects
        // insert the objects into the IRP list
 
    /* Set our cancel routine for cleanup */
    IoSetCancelRoutine(Irp, WmipNotificationIrpCancel);
 
    /* Check if the IRP is already being cancelled */
    if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
    {
        Status = STATUS_CANCELLED;
    }
    else
    {
        /* Mark the IRP as pending */
        IoMarkIrpPending(Irp);
        Status = STATUS_PENDING;
    }
 
    return Status;
}

Referenced by WmipIoControl().

WmipRegisterGuids()

static NTSTATUS WmipRegisterGuids ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PVOID  Buffer, _In_ ULONG  InputLength, _Inout_ PULONG  OutputLength  )

static

Definition at line 174 of file wmidrv.c.

{
    PWMIP_REGISTER_GUIDS RegisterGuids = (PWMIP_REGISTER_GUIDS)Buffer;
    PWMIP_RESULT Result = (PWMIP_RESULT)Buffer;
    OBJECT_ATTRIBUTES LocalObjectAttributes;
    UNICODE_STRING LocalObjectName;
    WCHAR LocalObjectNameBuffer[45 + 1];
    KPROCESSOR_MODE PreviousMode;
    HANDLE GuidObjectHandle;
    PVOID GuidObject;
    NTSTATUS Status;
 
    /* Make sure the input buffer is large enough */
    if ((InputLength < sizeof(WMIP_REGISTER_GUIDS)) ||
        (RegisterGuids->RegInfo.BufferSize >
         (InputLength - FIELD_OFFSET(WMIP_REGISTER_GUIDS, RegInfo))))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Make sure we have a resonable GUID count */
    if ((RegisterGuids->RegInfo.GuidCount == 0) ||
        (RegisterGuids->RegInfo.GuidCount > 0x10000))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Capture object attributes */
    PreviousMode = ExGetPreviousMode();
    Status = WmipCaptureGuidObjectAttributes(RegisterGuids->ObjectAttributes,
                                             &LocalObjectAttributes,
                                             &LocalObjectName,
                                             LocalObjectNameBuffer,
                                             PreviousMode);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("WmipCaptureGuidObjectAttributes failed: 0x%lx\n", Status);
        return Status;
    }
 
    /* Open a new GUID object */
    Status = WmipOpenGuidObjectByName(&LocalObjectAttributes,
                                      SPECIFIC_RIGHTS_ALL,
                                      PreviousMode,
                                      &GuidObjectHandle,
                                      &GuidObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("WmipOpenGuidObjectByName failed: 0x%lx\n", Status);
        return Status;
    }
 
    /* Dereference the GUID object */
    ObDereferenceObject(GuidObject);
 
    /* Return the handle (user mode will close it) */
    Result->Handle = GuidObjectHandle;
    Result->TraceHandle = 0;
    *OutputLength = 24;
 
    return STATUS_SUCCESS;
}

Referenced by WmipIoControl().

WmipShutdown()

NTSTATUS NTAPI WmipShutdown	(	_Inout_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 551 of file wmidrv.c.

{
    Irp->IoStatus.Status = STATUS_SUCCESS;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

WmipSystemControl()

NTSTATUS NTAPI WmipSystemControl	(	_Inout_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 541 of file wmidrv.c.

{
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_NOT_IMPLEMENTED;
}

WmipUnregisterGuids()

static NTSTATUS WmipUnregisterGuids ( _In_ PVOID  Buffer, _In_ ULONG  InputLength, _Inout_ PULONG  OutputLength  )

static

Definition at line 244 of file wmidrv.c.

{
    /* For now we have nothing to do */
    return STATUS_SUCCESS;
}

Referenced by WmipIoControl().

WmiSetMark()

static NTSTATUS WmiSetMark ( PWMI_SET_MARK  Buffer, ULONG  Length  )

static

Definition at line 438 of file wmidrv.c.

{
    UNIMPLEMENTED;
    return STATUS_SUCCESS;
}

Referenced by WmipIoControl().

WmiTraceEvent()

static NTSTATUS WmiTraceEvent ( PVOID  InputBuffer, KPROCESSOR_MODE  PreviousMode  )

static

Definition at line 101 of file wmidrv.c.

{
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_SUCCESS;
}

Referenced by _Function_class_().

WmiTraceUserMessage()

static NTSTATUS WmiTraceUserMessage ( PVOID  InputBuffer, ULONG  InputBufferLength  )

static

Definition at line 111 of file wmidrv.c.

{
    UNIMPLEMENTED_DBGBREAK();
    return STATUS_SUCCESS;
}

Referenced by _Function_class_().

Variable Documentation

WmipAdminDeviceObject

PDEVICE_OBJECT WmipAdminDeviceObject

Definition at line 73 of file wmidrv.c.

Referenced by _Function_class_().

WmipFastIoDispatch

FAST_IO_DISPATCH WmipFastIoDispatch

Definition at line 74 of file wmidrv.c.

Referenced by _Function_class_().

WmipIoControl

DRIVER_DISPATCH WmipIoControl

Definition at line 80 of file wmidrv.c.

Referenced by _Function_class_().

WmipOpenCloseCleanup

DRIVER_DISPATCH WmipOpenCloseCleanup

Definition at line 79 of file wmidrv.c.

Referenced by _Function_class_().

WmipServiceDeviceObject

PDEVICE_OBJECT WmipServiceDeviceObject

Definition at line 72 of file wmidrv.c.

Referenced by _Function_class_().

WmipShutdown

DRIVER_DISPATCH WmipShutdown

Definition at line 82 of file wmidrv.c.

Referenced by _Function_class_().

WmipSystemControl

DRIVER_DISPATCH WmipSystemControl

Definition at line 81 of file wmidrv.c.

Referenced by _Function_class_().