kbdclass.c File Reference

#include "kbdclass.h"
#include <stdio.h>
#include <kbdmou.h>
#include <hidclass.h>
#include <poclass.h>
#include <pseh/pseh2.h>
#include <debug.h>

Include dependency graph for kbdclass.c:

Go to the source code of this file.

Functions
static NTSTATUS	HandleReadIrp (IN PDEVICE_OBJECT DeviceObject, IN PREAD_DATA ReadData, IN PIRP Irp OPTIONAL)
static VOID NTAPI	DriverUnload (IN PDRIVER_OBJECT DriverObject)
static NTSTATUS NTAPI	ClassCreate (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	ClassClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	ClassCleanup (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	ClassRead (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	ClassDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	ClassPower (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS	ReadRegistryEntries (IN PUNICODE_STRING RegistryPath, IN PCLASS_DRIVER_EXTENSION DriverExtension)
static NTSTATUS	CreateClassDeviceObject (IN PDRIVER_OBJECT DriverObject, OUT PDEVICE_OBJECT *ClassDO OPTIONAL)
static NTSTATUS	FillEntries (IN PDEVICE_OBJECT ClassDeviceObject, IN PKEYBOARD_INPUT_DATA Source, OUT PKEYBOARD_INPUT_DATA Destination, IN SIZE_T NumberOfEntries)
static BOOLEAN NTAPI	ClassCallback (IN PDEVICE_OBJECT ClassDeviceObject, IN OUT PKEYBOARD_INPUT_DATA DataStart, IN PKEYBOARD_INPUT_DATA DataEnd, IN OUT PULONG ConsumedCount)
static NTSTATUS	ConnectPortDriver (IN PDEVICE_OBJECT PortDO, IN PDEVICE_OBJECT ClassDO)
static VOID	DestroyPortDriver (IN PDEVICE_OBJECT PortDO)
static NTSTATUS NTAPI	ClassAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo)
static VOID NTAPI	ClassCancelRoutine (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static NTSTATUS NTAPI	ClassPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static VOID NTAPI	ClassStartIo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
static VOID NTAPI	SearchForLegacyDrivers (IN PDRIVER_OBJECT DriverObject, IN PVOID Context, IN ULONG Count)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)

Variables
static DRIVER_UNLOAD	DriverUnload
static DRIVER_DISPATCH	ClassCreate
static DRIVER_DISPATCH	ClassClose
static DRIVER_DISPATCH	ClassCleanup
static DRIVER_DISPATCH	ClassRead
static DRIVER_DISPATCH	ClassDeviceControl
static DRIVER_DISPATCH	ClassPower
static DRIVER_ADD_DEVICE	ClassAddDevice
static DRIVER_STARTIO	ClassStartIo
static DRIVER_CANCEL	ClassCancelRoutine

Function Documentation

ClassAddDevice()

static NTSTATUS NTAPI ClassAddDevice ( IN PDRIVER_OBJECT  DriverObject, IN PDEVICE_OBJECT  Pdo  )

static

Definition at line 680 of file kbdclass.c.

{
    PCLASS_DRIVER_EXTENSION DriverExtension;
    PDEVICE_OBJECT Fdo = NULL;
    PPORT_DEVICE_EXTENSION DeviceExtension = NULL;
    NTSTATUS Status;
 
    TRACE_(CLASS_NAME, "ClassAddDevice called. Pdo = 0x%p\n", Pdo);
 
    DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
 
    if (Pdo == NULL)
        /* We may get a NULL Pdo at the first call as we're a legacy driver. Ignore it */
        return STATUS_SUCCESS;
 
    /* Create new device object */
    Status = IoCreateDevice(
        DriverObject,
        sizeof(PORT_DEVICE_EXTENSION),
        NULL,
        Pdo->DeviceType,
        Pdo->Characteristics & FILE_DEVICE_SECURE_OPEN ? FILE_DEVICE_SECURE_OPEN : 0,
        FALSE,
        &Fdo);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "IoCreateDevice() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
    IoSetStartIoAttributes(Fdo, TRUE, TRUE);
 
    DeviceExtension = (PPORT_DEVICE_EXTENSION)Fdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(PORT_DEVICE_EXTENSION));
    DeviceExtension->Common.IsClassDO = FALSE;
    DeviceExtension->DeviceObject = Fdo;
    DeviceExtension->PnpState = dsStopped;
    Status = IoAttachDeviceToDeviceStackSafe(Fdo, Pdo, &DeviceExtension->LowerDevice);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "IoAttachDeviceToDeviceStackSafe() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
    if (DeviceExtension->LowerDevice->Flags & DO_POWER_PAGABLE)
        Fdo->Flags |= DO_POWER_PAGABLE;
    if (DeviceExtension->LowerDevice->Flags & DO_BUFFERED_IO)
        Fdo->Flags |= DO_BUFFERED_IO;
    if (DeviceExtension->LowerDevice->Flags & DO_DIRECT_IO)
        Fdo->Flags |= DO_DIRECT_IO;
 
    if (DriverExtension->ConnectMultiplePorts)
        DeviceExtension->ClassDO = DriverExtension->MainClassDeviceObject;
    else
    {
        /* We need a new class device object for this Fdo */
        Status = CreateClassDeviceObject(
            DriverObject,
            &DeviceExtension->ClassDO);
        if (!NT_SUCCESS(Status))
        {
            WARN_(CLASS_NAME, "CreateClassDeviceObject() failed with status 0x%08lx\n", Status);
            goto cleanup;
        }
    }
    Status = ConnectPortDriver(Fdo, DeviceExtension->ClassDO);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "ConnectPortDriver() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
    Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    /* Register interface ; ignore the error (if any) as having
     * a registered interface is not so important... */
    Status = IoRegisterDeviceInterface(
        Pdo,
        &GUID_DEVINTERFACE_KEYBOARD,
        NULL,
        &DeviceExtension->InterfaceName);
    if (!NT_SUCCESS(Status))
        DeviceExtension->InterfaceName.Length = 0;
 
    return STATUS_SUCCESS;
 
cleanup:
    if (Fdo)
        DestroyPortDriver(Fdo);
    return Status;
}

ClassCallback()

static BOOLEAN NTAPI ClassCallback ( IN PDEVICE_OBJECT  ClassDeviceObject, IN OUT PKEYBOARD_INPUT_DATA  DataStart, IN PKEYBOARD_INPUT_DATA  DataEnd, IN OUT PULONG  ConsumedCount  )

static

Definition at line 511 of file kbdclass.c.

{
    PCLASS_DEVICE_EXTENSION ClassDeviceExtension = ClassDeviceObject->DeviceExtension;
    KIRQL OldIrql;
    SIZE_T InputCount = DataEnd - DataStart;
    SIZE_T ReadSize;
 
    TRACE_(CLASS_NAME, "ClassCallback()\n");
 
    ASSERT(ClassDeviceExtension->Common.IsClassDO);
 
    if (InputCount > 0)
    {
        KeAcquireSpinLock(&ClassDeviceExtension->ReadData->SpinLock, &OldIrql);
        if (ClassDeviceExtension->ReadData->InputCount + InputCount > ClassDeviceExtension->DriverExtension->DataQueueSize)
        {
            /*
             * We're exceeding the buffer, and data will be thrown away...
             * FIXME: What could we do, as we are at DISPATCH_LEVEL?
             */
            ReadSize = ClassDeviceExtension->DriverExtension->DataQueueSize - ClassDeviceExtension->ReadData->InputCount;
        }
        else
            ReadSize = InputCount;
 
        /*
         * Move the input data from the port data queue to our class data
         * queue.
         */
        RtlCopyMemory(
            &ClassDeviceExtension->ReadData->PortData[ClassDeviceExtension->ReadData->InputCount],
            (PCHAR)DataStart,
            sizeof(KEYBOARD_INPUT_DATA) * ReadSize);
 
        /* Move the counter up */
        ClassDeviceExtension->ReadData->InputCount += ReadSize;
 
        (*ConsumedCount) += (ULONG)ReadSize;
 
        KeReleaseSpinLock(&ClassDeviceExtension->ReadData->SpinLock, OldIrql);
 
        /* Complete pending IRP (if any) */
        HandleReadIrp(ClassDeviceObject, ClassDeviceExtension->ReadData, NULL);
    }
 
    TRACE_(CLASS_NAME, "Leaving ClassCallback()\n");
    return TRUE;
}

Referenced by ConnectPortDriver().

ClassCancelRoutine()

static VOID NTAPI ClassCancelRoutine ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 772 of file kbdclass.c.

{
    PCOMMON_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    PREAD_DATA ReadData;
    KIRQL OldIrql;
    BOOLEAN wasQueued = FALSE;
 
    TRACE_(CLASS_NAME, "ClassCancelRoutine(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
 
    if (DeviceExtension->IsClassDO)
    {
        ReadData = ((PCLASS_DEVICE_EXTENSION)DeviceExtension)->ReadData;
    }
    else
    {
        PPORT_DEVICE_EXTENSION Port = (PPORT_DEVICE_EXTENSION)DeviceExtension;
        PCLASS_DEVICE_EXTENSION Class = (PCLASS_DEVICE_EXTENSION)Port->ClassDO->DeviceExtension;
        ReadData = Class->ReadData;
    }
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    KeAcquireSpinLock(&ReadData->SpinLock, &OldIrql);
 
    if (ReadData->PendingIrp == Irp)
    {
        ReadData->PendingIrp = NULL;
        wasQueued = TRUE;
    }
    KeReleaseSpinLock(&ReadData->SpinLock, OldIrql);
 
    if (wasQueued)
    {
        Irp->IoStatus.Status = STATUS_CANCELLED;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
    else
    {
        DPRINT1("Cancelled IRP is not pending. Race condition?\n");
    }
}

ClassCleanup()

static NTSTATUS NTAPI ClassCleanup ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 76 of file kbdclass.c.

{
    TRACE_(CLASS_NAME, "IRP_MJ_CLEANUP\n");
 
    if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
        return ForwardIrpAndForget(DeviceObject, Irp);
 
    /* FIXME: cleanup all associated Port devices */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

ClassClose()

static NTSTATUS NTAPI ClassClose ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 59 of file kbdclass.c.

{
    TRACE_(CLASS_NAME, "IRP_MJ_CLOSE\n");
 
    if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
        return ForwardIrpAndForget(DeviceObject, Irp);
 
    /* FIXME: close all associated Port devices */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

ClassCreate()

static NTSTATUS NTAPI ClassCreate ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 42 of file kbdclass.c.

{
    TRACE_(CLASS_NAME, "IRP_MJ_CREATE\n");
 
    if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
        return ForwardIrpAndForget(DeviceObject, Irp);
 
    /* FIXME: open all associated Port devices */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}

ClassDeviceControl()

static NTSTATUS NTAPI ClassDeviceControl ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 126 of file kbdclass.c.

{
    NTSTATUS Status = STATUS_NOT_SUPPORTED;
 
    TRACE_(CLASS_NAME, "IRP_MJ_DEVICE_CONTROL\n");
 
    switch (IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_KEYBOARD_QUERY_ATTRIBUTES:
        case IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION:
        case IOCTL_KEYBOARD_QUERY_INDICATORS:
        case IOCTL_KEYBOARD_QUERY_TYPEMATIC:
        {
            if (((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
            {
                /* FIXME: We hope that all devices will return the same result.
                 * Ask only the first one */
                PLIST_ENTRY Head = &((PCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->ListHead;
                if (Head->Flink != Head)
                {
                    /* We have at least one device */
                    PPORT_DEVICE_EXTENSION DevExt = CONTAINING_RECORD(Head->Flink, PORT_DEVICE_EXTENSION, ListEntry);
                    DeviceObject = DevExt->DeviceObject;
                }
                else
                    DeviceObject = NULL;
            }
            if (DeviceObject)
            {
                IoCopyCurrentIrpStackLocationToNext(Irp);
                IoGetNextIrpStackLocation(Irp)->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
                return IoCallDriver(DeviceObject, Irp);
            }
            break;
        }
        case IOCTL_KEYBOARD_SET_INDICATORS:
        case IOCTL_KEYBOARD_SET_TYPEMATIC: /* not in MSDN, would seem logical */
        {
            if (((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
            {
                /* Send it to all associated Port devices */
                PLIST_ENTRY Head = &((PCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->ListHead;
                PLIST_ENTRY Entry = Head->Flink;
                Status = STATUS_SUCCESS;
                while (Entry != Head)
                {
                    PPORT_DEVICE_EXTENSION DevExt = CONTAINING_RECORD(Entry, PORT_DEVICE_EXTENSION, ListEntry);
 
                    IoGetCurrentIrpStackLocation(Irp)->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
 
                    if (IoForwardIrpSynchronously(DevExt->LowerDevice, Irp))
                    {
                        if (!NT_SUCCESS(Irp->IoStatus.Status))
                        {
                            Status = Irp->IoStatus.Status;
                        }
                    }
                    else
                    {
                        Status = STATUS_UNSUCCESSFUL;
                    }
 
                    Entry = Entry->Flink;
                }
            }
            else
            {
                PPORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(DeviceExtension->LowerDevice, Irp);
            }
            break;
        }
        /* Every IOCTL HID, except IOCTL_HID_GET_INPUT_REPORT/IOCTL_HID_SET_OUTPUT_REPORT */
        case IOCTL_GET_PHYSICAL_DESCRIPTOR:
        case IOCTL_HID_FLUSH_QUEUE:
        case IOCTL_HID_GET_COLLECTION_DESCRIPTOR:
        case IOCTL_HID_GET_COLLECTION_INFORMATION:
        case IOCTL_HID_GET_FEATURE:
        case IOCTL_HID_GET_HARDWARE_ID:
        case IOCTL_HID_GET_INDEXED_STRING:
        case IOCTL_HID_GET_MANUFACTURER_STRING:
        case IOCTL_GET_NUM_DEVICE_INPUT_BUFFERS:
        case IOCTL_HID_GET_POLL_FREQUENCY_MSEC:
        case IOCTL_HID_GET_PRODUCT_STRING:
        case IOCTL_HID_GET_SERIALNUMBER_STRING:
        case IOCTL_HID_SET_FEATURE:
        case IOCTL_SET_NUM_DEVICE_INPUT_BUFFERS:
        case IOCTL_HID_SET_POLL_FREQUENCY_MSEC:
        case IOCTL_HID_GET_DRIVER_CONFIG:
        case IOCTL_HID_SET_DRIVER_CONFIG:
        case IOCTL_HID_GET_MS_GENRE_DESCRIPTOR:
        /* IOCTL used by Power Manager */
        case IOCTL_GET_SYS_BUTTON_CAPS:
        case IOCTL_GET_SYS_BUTTON_EVENT:
        {
            PPORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
            if (!DeviceExtension->Common.IsClassDO)
            {
                IoSkipCurrentIrpStackLocation(Irp);
                return IoCallDriver(DeviceExtension->LowerDevice, Irp);
            }
            break;
        }
        default:
            WARN_(CLASS_NAME, "IRP_MJ_DEVICE_CONTROL / unknown I/O control code 0x%lx\n",
                IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode);
            ASSERT(FALSE);
            break;
    }
 
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

ClassPnp()

static NTSTATUS NTAPI ClassPnp ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 900 of file kbdclass.c.

{
    PPORT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
            if (IoForwardIrpSynchronously(DeviceExtension->LowerDevice, Irp))
            {
                Status = Irp->IoStatus.Status;
            }
            else
            {
                Status = STATUS_UNSUCCESSFUL;
            }
 
            if (NT_SUCCESS(Status))
            {
                InitializeObjectAttributes(&ObjectAttributes,
                                           &DeviceExtension->InterfaceName,
                                           OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                           NULL,
                                           NULL);
 
                Status = ZwOpenFile(&DeviceExtension->FileHandle,
                                    FILE_READ_DATA,
                                    &ObjectAttributes,
                                    &Iosb,
                                    0,
                                    0);
                if (!NT_SUCCESS(Status))
                    DeviceExtension->FileHandle = NULL;
            }
            else
                DeviceExtension->FileHandle = NULL;
            if (DeviceExtension->InterfaceName.Length != 0)
                IoSetDeviceInterfaceState(&DeviceExtension->InterfaceName, TRUE);
            Irp->IoStatus.Status = Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
 
        case IRP_MN_STOP_DEVICE:
            if (DeviceExtension->FileHandle)
            {
                ZwClose(DeviceExtension->FileHandle);
                DeviceExtension->FileHandle = NULL;
            }
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_REMOVE_DEVICE:
            if (DeviceExtension->InterfaceName.Length != 0)
                IoSetDeviceInterfaceState(&DeviceExtension->InterfaceName, FALSE);
            if (DeviceExtension->FileHandle)
            {
                ZwClose(DeviceExtension->FileHandle);
                DeviceExtension->FileHandle = NULL;
            }
            IoSkipCurrentIrpStackLocation(Irp);
            Status = IoCallDriver(DeviceExtension->LowerDevice, Irp);
            DestroyPortDriver(DeviceObject);
            return Status;
 
        default:
            Status = Irp->IoStatus.Status;
            break;
    }
 
    Irp->IoStatus.Status = Status;
    if (NT_SUCCESS(Status) || Status == STATUS_NOT_SUPPORTED)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(DeviceExtension->LowerDevice, Irp);
    }
    else
    {
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

Referenced by DriverEntry().

ClassPower()

static NTSTATUS NTAPI ClassPower ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 247 of file kbdclass.c.

{
    NTSTATUS Status;
    PPORT_DEVICE_EXTENSION DeviceExtension;
 
    DeviceExtension = DeviceObject->DeviceExtension;
    if (!DeviceExtension->Common.IsClassDO)
    {
        /* Forward port DO IRPs to lower device */
        PoStartNextPowerIrp(Irp);
        IoSkipCurrentIrpStackLocation(Irp);
        return PoCallDriver(DeviceExtension->LowerDevice, Irp);
    }
 
    switch (IoGetCurrentIrpStackLocation(Irp)->MinorFunction)
    {
        case IRP_MN_SET_POWER:
        case IRP_MN_QUERY_POWER:
            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
    }
    Status = Irp->IoStatus.Status;
    PoStartNextPowerIrp(Irp);
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

ClassRead()

static NTSTATUS NTAPI ClassRead ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 93 of file kbdclass.c.

{
    PCOMMON_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    PREAD_DATA ReadData;
 
    TRACE_(CLASS_NAME, "IRP_MJ_READ\n");
 
    if (IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length < sizeof(KEYBOARD_INPUT_DATA))
    {
        Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    if (DeviceExtension->IsClassDO)
    {
        ReadData = ((PCLASS_DEVICE_EXTENSION)DeviceExtension)->ReadData;
    }
    else
    {
        PPORT_DEVICE_EXTENSION Port = (PPORT_DEVICE_EXTENSION)DeviceExtension;
        PCLASS_DEVICE_EXTENSION Class = (PCLASS_DEVICE_EXTENSION)Port->ClassDO->DeviceExtension;
        ReadData = Class->ReadData;
    }
 
    return HandleReadIrp(DeviceObject, ReadData, Irp);
}

ClassStartIo()

static VOID NTAPI ClassStartIo ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

static

Definition at line 988 of file kbdclass.c.

{
    PCLASS_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
 
    TRACE_(CLASS_NAME, "ClassStartIo(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
 
    ASSERT(DeviceExtension->Common.IsClassDO);
 
    HandleReadIrp(DeviceObject, DeviceExtension->ReadData, Irp);
}

ConnectPortDriver()

static NTSTATUS ConnectPortDriver ( IN PDEVICE_OBJECT  PortDO, IN PDEVICE_OBJECT  ClassDO  )

static

Definition at line 566 of file kbdclass.c.

{
    KEVENT Event;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    CONNECT_DATA ConnectData;
    NTSTATUS Status;
 
    TRACE_(CLASS_NAME, "Connecting PortDO %p to ClassDO %p\n", PortDO, ClassDO);
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    ConnectData.ClassDeviceObject = ClassDO;
    ConnectData.ClassService      = ClassCallback;
 
    Irp = IoBuildDeviceIoControlRequest(
        IOCTL_INTERNAL_KEYBOARD_CONNECT,
        PortDO,
        &ConnectData, sizeof(CONNECT_DATA),
        NULL, 0,
        TRUE, &Event, &IoStatus);
    if (!Irp)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = IoCallDriver(PortDO, Irp);
 
    if (Status == STATUS_PENDING)
        KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
    else
        IoStatus.Status = Status;
 
    if (NT_SUCCESS(IoStatus.Status))
    {
        ObReferenceObject(PortDO);
        ExInterlockedInsertTailList(
            &((PCLASS_DEVICE_EXTENSION)ClassDO->DeviceExtension)->ListHead,
            &((PPORT_DEVICE_EXTENSION)PortDO->DeviceExtension)->ListEntry,
            &((PCLASS_DEVICE_EXTENSION)ClassDO->DeviceExtension)->ListSpinLock);
        if (ClassDO->StackSize <= PortDO->StackSize)
        {
            /* Increase the stack size, in case we have to
             * forward some IRPs to the port device object
             */
            ClassDO->StackSize = PortDO->StackSize + 1;
        }
    }
 
    return IoStatus.Status;
}

Referenced by ClassAddDevice().

CreateClassDeviceObject()

static NTSTATUS CreateClassDeviceObject ( IN PDRIVER_OBJECT  DriverObject, OUT PDEVICE_OBJECT *ClassDO  OPTIONAL  )

static

Definition at line 360 of file kbdclass.c.

{
    PCLASS_DRIVER_EXTENSION DriverExtension;
    ULONG DeviceId = 0;
    ULONG PrefixLength;
    UNICODE_STRING DeviceNameU;
    PWSTR DeviceIdW = NULL; /* Pointer into DeviceNameU.Buffer */
    PDEVICE_OBJECT Fdo;
    PCLASS_DEVICE_EXTENSION DeviceExtension;
    NTSTATUS Status;
 
    TRACE_(CLASS_NAME, "CreateClassDeviceObject(0x%p)\n", DriverObject);
 
    /* Create new device object */
    DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
    DeviceNameU.Length = 0;
    DeviceNameU.MaximumLength =
        (USHORT)wcslen(L"\\Device\\") * sizeof(WCHAR) /* "\Device\" */
        + DriverExtension->DeviceBaseName.Length /* "KeyboardClass" */
        + 4 * sizeof(WCHAR)                      /* Id between 0 and 9999 */
        + sizeof(UNICODE_NULL);                  /* Final NULL char */
    DeviceNameU.Buffer = ExAllocatePoolWithTag(PagedPool, DeviceNameU.MaximumLength, CLASS_TAG);
    if (!DeviceNameU.Buffer)
    {
        WARN_(CLASS_NAME, "ExAllocatePoolWithTag() failed\n");
        return STATUS_NO_MEMORY;
    }
    Status = RtlAppendUnicodeToString(&DeviceNameU, L"\\Device\\");
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "RtlAppendUnicodeToString() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
    Status = RtlAppendUnicodeStringToString(&DeviceNameU, &DriverExtension->DeviceBaseName);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "RtlAppendUnicodeStringToString() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
    PrefixLength = DeviceNameU.MaximumLength - 4 * sizeof(WCHAR) - sizeof(UNICODE_NULL);
    DeviceIdW = &DeviceNameU.Buffer[PrefixLength / sizeof(WCHAR)];
    while (DeviceId < 9999)
    {
        DeviceNameU.Length = (USHORT)(PrefixLength + _swprintf(DeviceIdW, L"%lu", DeviceId) * sizeof(WCHAR));
        Status = IoCreateDevice(
            DriverObject,
            sizeof(CLASS_DEVICE_EXTENSION),
            &DeviceNameU,
            FILE_DEVICE_KEYBOARD,
            FILE_DEVICE_SECURE_OPEN,
            FALSE,
            &Fdo);
        if (NT_SUCCESS(Status))
            goto cleanup;
        else if (Status != STATUS_OBJECT_NAME_COLLISION)
        {
            WARN_(CLASS_NAME, "IoCreateDevice() failed with status 0x%08lx\n", Status);
            goto cleanup;
        }
        DeviceId++;
    }
    WARN_(CLASS_NAME, "Too many devices starting with '\\Device\\%wZ'\n", &DriverExtension->DeviceBaseName);
    Status = STATUS_TOO_MANY_NAMES;
cleanup:
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(DeviceNameU.Buffer, CLASS_TAG);
        return Status;
    }
 
    DeviceExtension = (PCLASS_DEVICE_EXTENSION)Fdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(CLASS_DEVICE_EXTENSION));
    DeviceExtension->Common.IsClassDO = TRUE;
    DeviceExtension->DriverExtension = DriverExtension;
    InitializeListHead(&DeviceExtension->ListHead);
    KeInitializeSpinLock(&DeviceExtension->ListSpinLock);
    DeviceExtension->ReadData = ExAllocatePoolZero(NonPagedPool, sizeof(READ_DATA), CLASS_TAG);
    if (!DeviceExtension->ReadData)
    {
        ExFreePoolWithTag(DeviceNameU.Buffer, CLASS_TAG);
        return STATUS_NO_MEMORY;
    }
    KeInitializeSpinLock(&DeviceExtension->ReadData->SpinLock);
    DeviceExtension->ReadData->PortData = ExAllocatePoolWithTag(NonPagedPool, DeviceExtension->DriverExtension->DataQueueSize * sizeof(KEYBOARD_INPUT_DATA), CLASS_TAG);
    if (!DeviceExtension->ReadData->PortData)
    {
        ExFreePoolWithTag(DeviceNameU.Buffer, CLASS_TAG);
        ExFreePoolWithTag(DeviceExtension->ReadData, CLASS_TAG);
        return STATUS_NO_MEMORY;
    }
    DeviceExtension->DeviceName = DeviceNameU.Buffer;
    Fdo->Flags |= DO_POWER_PAGABLE;
    Fdo->Flags |= DO_BUFFERED_IO; /* FIXME: Why is it needed for 1st stage setup? */
    Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    /* Add entry entry to HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\[DeviceBaseName] */
    RtlWriteRegistryValue(
        RTL_REGISTRY_DEVICEMAP,
        DriverExtension->DeviceBaseName.Buffer,
        DeviceExtension->DeviceName,
        REG_SZ,
        DriverExtension->RegistryPath.Buffer,
        DriverExtension->RegistryPath.MaximumLength);
 
    if (ClassDO)
        *ClassDO = Fdo;
 
    return STATUS_SUCCESS;
}

Referenced by ClassAddDevice(), and DriverEntry().

DestroyPortDriver()

static VOID DestroyPortDriver ( IN PDEVICE_OBJECT  PortDO )

static

Definition at line 620 of file kbdclass.c.

{
    PPORT_DEVICE_EXTENSION DeviceExtension;
    PCLASS_DEVICE_EXTENSION ClassDeviceExtension;
    PCLASS_DRIVER_EXTENSION DriverExtension;
    KEVENT Event;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    KIRQL OldIrql;
    NTSTATUS Status;
 
    TRACE_(CLASS_NAME, "Destroying PortDO %p\n", PortDO);
 
    DeviceExtension = (PPORT_DEVICE_EXTENSION)PortDO->DeviceExtension;
    ClassDeviceExtension = DeviceExtension->ClassDO->DeviceExtension;
    DriverExtension = IoGetDriverObjectExtension(PortDO->DriverObject, PortDO->DriverObject);
 
    /* Send IOCTL_INTERNAL_*_DISCONNECT */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp = IoBuildDeviceIoControlRequest(
        IOCTL_INTERNAL_KEYBOARD_DISCONNECT,
        PortDO,
        NULL, 0,
        NULL, 0,
        TRUE, &Event, &IoStatus);
    if (Irp)
    {
        Status = IoCallDriver(PortDO, Irp);
        if (Status == STATUS_PENDING)
            KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
    }
 
    /* Remove from ClassDeviceExtension->ListHead list */
    KeAcquireSpinLock(&ClassDeviceExtension->ListSpinLock, &OldIrql);
    RemoveEntryList(&DeviceExtension->ListEntry);
    KeReleaseSpinLock(&ClassDeviceExtension->ListSpinLock, OldIrql);
 
    /* Remove entry from HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\[DeviceBaseName] */
    RtlDeleteRegistryValue(
        RTL_REGISTRY_DEVICEMAP,
        DriverExtension->DeviceBaseName.Buffer,
        ClassDeviceExtension->DeviceName);
 
    if (DeviceExtension->LowerDevice)
        IoDetachDevice(DeviceExtension->LowerDevice);
    ObDereferenceObject(PortDO);
 
    if (!DriverExtension->ConnectMultiplePorts && DeviceExtension->ClassDO)
    {
        ExFreePoolWithTag(ClassDeviceExtension->ReadData->PortData, CLASS_TAG);
        ExFreePoolWithTag(ClassDeviceExtension->ReadData, CLASS_TAG);
        ExFreePoolWithTag((PVOID)ClassDeviceExtension->DeviceName, CLASS_TAG);
        IoDeleteDevice(DeviceExtension->ClassDO);
    }
 
    IoDeleteDevice(PortDO);
}

Referenced by ClassAddDevice(), and ClassPnp().

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 1120 of file kbdclass.c.

{
    PCLASS_DRIVER_EXTENSION DriverExtension;
    NTSTATUS Status;
 
    Status = IoAllocateDriverObjectExtension(
        DriverObject,
        DriverObject,
        sizeof(CLASS_DRIVER_EXTENSION),
        (PVOID*)&DriverExtension);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
        return Status;
    }
    RtlZeroMemory(DriverExtension, sizeof(CLASS_DRIVER_EXTENSION));
 
    Status = DuplicateUnicodeString(
        RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
        RegistryPath,
        &DriverExtension->RegistryPath);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "DuplicateUnicodeString() failed with status 0x%08lx\n", Status);
        return Status;
    }
 
    Status = ReadRegistryEntries(RegistryPath, DriverExtension);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "ReadRegistryEntries() failed with status 0x%08lx\n", Status);
        return Status;
    }
 
    if (DriverExtension->ConnectMultiplePorts == 1)
    {
        Status = CreateClassDeviceObject(
            DriverObject,
            &DriverExtension->MainClassDeviceObject);
        if (!NT_SUCCESS(Status))
        {
            WARN_(CLASS_NAME, "CreateClassDeviceObject() failed with status 0x%08lx\n", Status);
            return Status;
        }
    }
 
    DriverObject->DriverExtension->AddDevice = ClassAddDevice;
    DriverObject->DriverUnload = DriverUnload;
 
    DriverObject->MajorFunction[IRP_MJ_CREATE]         = ClassCreate;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]          = ClassClose;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP]        = ClassCleanup;
    DriverObject->MajorFunction[IRP_MJ_READ]           = ClassRead;
    DriverObject->MajorFunction[IRP_MJ_POWER]          = ClassPower;
    DriverObject->MajorFunction[IRP_MJ_PNP]            = ClassPnp;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ClassDeviceControl;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = ForwardIrpAndForget;
    DriverObject->DriverStartIo                        = ClassStartIo;
 
    /* We will detect the legacy devices later */
    IoRegisterDriverReinitialization(
        DriverObject,
        SearchForLegacyDrivers,
        DriverExtension);
 
    return STATUS_SUCCESS;
}

DriverUnload()

static VOID NTAPI DriverUnload ( IN PDRIVER_OBJECT  DriverObject )

static

Definition at line 36 of file kbdclass.c.

{
    // nothing to do here yet
}

FillEntries()

static NTSTATUS FillEntries ( IN PDEVICE_OBJECT  ClassDeviceObject, IN PKEYBOARD_INPUT_DATA  Source, OUT PKEYBOARD_INPUT_DATA  Destination, IN SIZE_T  NumberOfEntries  )

static

Definition at line 473 of file kbdclass.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (!Destination)
        return STATUS_UNSUCCESSFUL;
 
    if (ClassDeviceObject->Flags & (DO_BUFFERED_IO | DO_DIRECT_IO))
    {
        RtlCopyMemory(
            Destination,
            Source,
            NumberOfEntries * sizeof(KEYBOARD_INPUT_DATA));
    }
    else
    {
        _SEH2_TRY
        {
            RtlCopyMemory(
                Destination,
                Source,
                NumberOfEntries * sizeof(KEYBOARD_INPUT_DATA));
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
 
    return Status;
}

Referenced by HandleReadIrp().

HandleReadIrp()

static NTSTATUS HandleReadIrp ( IN PDEVICE_OBJECT  DeviceObject, IN PREAD_DATA  ReadData, IN PIRP Irp  OPTIONAL  )

static

Definition at line 818 of file kbdclass.c.

{
    NTSTATUS Status;
    KIRQL OldIrql;
 
    TRACE_(CLASS_NAME, "HandleReadIrp(DeviceObject %p, ReadData %p, Irp %p)\n", DeviceObject, ReadData, Irp);
 
    if (!Irp)
        Irp = ReadData->PendingIrp;
    if (!Irp)
        return STATUS_SUCCESS;
 
    if (ReadData->InputCount > 0)
    {
        SIZE_T NumberOfEntries;
        PKEYBOARD_INPUT_DATA Destination;
 
        if (DeviceObject->Flags & DO_BUFFERED_IO)
            Destination = Irp->AssociatedIrp.SystemBuffer;
        else if (DeviceObject->Flags & DO_DIRECT_IO)
            Destination = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
        else
            Destination = Irp->UserBuffer;
 
        KeAcquireSpinLock(&ReadData->SpinLock, &OldIrql);
        NumberOfEntries = MIN(
            ReadData->InputCount,
            IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length / sizeof(KEYBOARD_INPUT_DATA));
 
        Status = FillEntries(
            DeviceObject,
            ReadData->PortData,
            Destination,
            NumberOfEntries);
 
        if (NT_SUCCESS(Status))
        {
            if (ReadData->InputCount > NumberOfEntries)
            {
                RtlMoveMemory(
                    &ReadData->PortData[0],
                    &ReadData->PortData[NumberOfEntries],
                    (ReadData->InputCount - NumberOfEntries) * sizeof(KEYBOARD_INPUT_DATA));
            }
 
            ReadData->InputCount -= NumberOfEntries;
 
            Irp->IoStatus.Information = NumberOfEntries * sizeof(KEYBOARD_INPUT_DATA);
        }
 
        /* Go to next packet and complete this request */
        Irp->IoStatus.Status = Status;
 
        (VOID)IoSetCancelRoutine(Irp, NULL);
        IoCompleteRequest(Irp, IO_KEYBOARD_INCREMENT);
        ReadData->PendingIrp = NULL;
        KeReleaseSpinLock(&ReadData->SpinLock, OldIrql);
 
        return Status;
    }
 
    IoAcquireCancelSpinLock(&OldIrql);
    if (Irp->Cancel)
    {
        ReadData->PendingIrp = NULL;
        Status = STATUS_CANCELLED;
    }
    else
    {
        IoMarkIrpPending(Irp);
        ReadData->PendingIrp = Irp;
        (VOID)IoSetCancelRoutine(Irp, ClassCancelRoutine);
        Status = STATUS_PENDING;
    }
    IoReleaseCancelSpinLock(OldIrql);
    return Status;
}

Referenced by ClassCallback(), ClassRead(), and ClassStartIo().

ReadRegistryEntries()

static NTSTATUS ReadRegistryEntries ( IN PUNICODE_STRING  RegistryPath, IN PCLASS_DRIVER_EXTENSION  DriverExtension  )

static

Definition at line 277 of file kbdclass.c.

{
    UNICODE_STRING ParametersRegistryKey;
    RTL_QUERY_REGISTRY_TABLE Parameters[4];
    NTSTATUS Status;
 
    ULONG DefaultConnectMultiplePorts = 1;
    ULONG DefaultDataQueueSize = 0x64;
    PCWSTR DefaultDeviceBaseName = L"KeyboardClass";
 
    ParametersRegistryKey.Length = 0;
    ParametersRegistryKey.MaximumLength = RegistryPath->Length + sizeof(L"\\Parameters") + sizeof(UNICODE_NULL);
    ParametersRegistryKey.Buffer = ExAllocatePoolWithTag(PagedPool, ParametersRegistryKey.MaximumLength, CLASS_TAG);
    if (!ParametersRegistryKey.Buffer)
    {
        WARN_(CLASS_NAME, "ExAllocatePoolWithTag() failed\n");
        return STATUS_NO_MEMORY;
    }
    RtlCopyUnicodeString(&ParametersRegistryKey, RegistryPath);
    RtlAppendUnicodeToString(&ParametersRegistryKey, L"\\Parameters");
    ParametersRegistryKey.Buffer[ParametersRegistryKey.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    RtlZeroMemory(Parameters, sizeof(Parameters));
 
    Parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
    Parameters[0].Name = L"ConnectMultiplePorts";
    Parameters[0].EntryContext = &DriverExtension->ConnectMultiplePorts;
    Parameters[0].DefaultType = REG_DWORD;
    Parameters[0].DefaultData = &DefaultConnectMultiplePorts;
    Parameters[0].DefaultLength = sizeof(ULONG);
 
    Parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
    Parameters[1].Name = L"KeyboardDataQueueSize";
    Parameters[1].EntryContext = &DriverExtension->DataQueueSize;
    Parameters[1].DefaultType = REG_DWORD;
    Parameters[1].DefaultData = &DefaultDataQueueSize;
    Parameters[1].DefaultLength = sizeof(ULONG);
 
    Parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
    Parameters[2].Name = L"KeyboardDeviceBaseName";
    Parameters[2].EntryContext = &DriverExtension->DeviceBaseName;
    Parameters[2].DefaultType = REG_SZ;
    Parameters[2].DefaultData = (PVOID)DefaultDeviceBaseName;
    Parameters[2].DefaultLength = 0;
 
    Status = RtlQueryRegistryValues(
        RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
        ParametersRegistryKey.Buffer,
        Parameters,
        NULL,
        NULL);
 
    if (NT_SUCCESS(Status))
    {
        /* Check values */
        if (DriverExtension->ConnectMultiplePorts != 0
            && DriverExtension->ConnectMultiplePorts != 1)
        {
            DriverExtension->ConnectMultiplePorts = DefaultConnectMultiplePorts;
        }
        if (DriverExtension->DataQueueSize == 0)
        {
            DriverExtension->DataQueueSize = DefaultDataQueueSize;
        }
    }
    else if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        /* Registry path doesn't exist. Set defaults */
        DriverExtension->ConnectMultiplePorts = DefaultConnectMultiplePorts;
        DriverExtension->DataQueueSize = DefaultDataQueueSize;
        if (RtlCreateUnicodeString(&DriverExtension->DeviceBaseName, DefaultDeviceBaseName))
            Status = STATUS_SUCCESS;
        else
            Status = STATUS_NO_MEMORY;
    }
 
    ExFreePoolWithTag(ParametersRegistryKey.Buffer, CLASS_TAG);
    return Status;
}

Referenced by DriverEntry().

SearchForLegacyDrivers()

static VOID NTAPI SearchForLegacyDrivers ( IN PDRIVER_OBJECT  DriverObject, IN PVOID  Context, IN ULONG  Count  )

static

Definition at line 1002 of file kbdclass.c.

{
    UNICODE_STRING DeviceMapKeyU = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\HARDWARE\\DEVICEMAP");
    PCLASS_DRIVER_EXTENSION DriverExtension;
    UNICODE_STRING PortBaseName = { 0, 0, NULL };
    PKEY_VALUE_BASIC_INFORMATION KeyValueInformation = NULL;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hDeviceMapKey = (HANDLE)-1;
    HANDLE hPortKey = (HANDLE)-1;
    ULONG Index = 0;
    ULONG Size, ResultLength;
    NTSTATUS Status;
 
    TRACE_(CLASS_NAME, "SearchForLegacyDrivers(%p %p %lu)\n",
        DriverObject, Context, Count);
 
    if (Count != 1)
        return;
    DriverExtension = (PCLASS_DRIVER_EXTENSION)Context;
 
    /* Create port base name, by replacing Class by Port at the end of the class base name */
    Status = DuplicateUnicodeString(
        RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
        &DriverExtension->DeviceBaseName,
        &PortBaseName);
    if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "DuplicateUnicodeString() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
    PortBaseName.Length -= (sizeof(L"Class") - sizeof(UNICODE_NULL));
    RtlAppendUnicodeToString(&PortBaseName, L"Port");
 
    /* Allocate memory */
    Size = sizeof(KEY_VALUE_BASIC_INFORMATION) + MAX_PATH;
    KeyValueInformation = ExAllocatePoolWithTag(PagedPool, Size, CLASS_TAG);
    if (!KeyValueInformation)
    {
        WARN_(CLASS_NAME, "ExAllocatePoolWithTag() failed\n");
        Status = STATUS_NO_MEMORY;
        goto cleanup;
    }
 
    /* Open HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP */
    InitializeObjectAttributes(&ObjectAttributes, &DeviceMapKeyU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
    Status = ZwOpenKey(&hDeviceMapKey, 0, &ObjectAttributes);
    if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        INFO_(CLASS_NAME, "HKLM\\HARDWARE\\DEVICEMAP is non-existent\n");
        Status = STATUS_SUCCESS;
        goto cleanup;
    }
    else if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "ZwOpenKey() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
 
    /* Open sub key */
    InitializeObjectAttributes(&ObjectAttributes, &PortBaseName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hDeviceMapKey, NULL);
    Status = ZwOpenKey(&hPortKey, KEY_QUERY_VALUE, &ObjectAttributes);
    if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        INFO_(CLASS_NAME, "HKLM\\HARDWARE\\DEVICEMAP\\%wZ is non-existent\n", &PortBaseName);
        Status = STATUS_SUCCESS;
        goto cleanup;
    }
    else if (!NT_SUCCESS(Status))
    {
        WARN_(CLASS_NAME, "ZwOpenKey() failed with status 0x%08lx\n", Status);
        goto cleanup;
    }
 
    /* Read each value name */
    while (ZwEnumerateValueKey(hPortKey, Index++, KeyValueBasicInformation, KeyValueInformation, Size, &ResultLength) == STATUS_SUCCESS)
    {
        UNICODE_STRING PortName;
        PDEVICE_OBJECT PortDeviceObject = NULL;
        PFILE_OBJECT FileObject = NULL;
 
        PortName.Length = PortName.MaximumLength = (USHORT)KeyValueInformation->NameLength;
        PortName.Buffer = KeyValueInformation->Name;
 
        /* Open the device object pointer */
        Status = IoGetDeviceObjectPointer(&PortName, FILE_READ_ATTRIBUTES, &FileObject, &PortDeviceObject);
        if (!NT_SUCCESS(Status))
        {
            WARN_(CLASS_NAME, "IoGetDeviceObjectPointer(%wZ) failed with status 0x%08lx\n", &PortName, Status);
            continue;
        }
        INFO_(CLASS_NAME, "Legacy driver found\n");
 
        Status = ClassAddDevice(DriverObject, PortDeviceObject);
        if (!NT_SUCCESS(Status))
        {
            /* FIXME: Log the error */
            WARN_(CLASS_NAME, "ClassAddDevice() failed with status 0x%08lx\n", Status);
        }
 
        ObDereferenceObject(FileObject);
    }
 
cleanup:
    if (KeyValueInformation != NULL)
        ExFreePoolWithTag(KeyValueInformation, CLASS_TAG);
    if (hDeviceMapKey != (HANDLE)-1)
        ZwClose(hDeviceMapKey);
    if (hPortKey != (HANDLE)-1)
        ZwClose(hPortKey);
}

Referenced by DriverEntry().

Variable Documentation

ClassAddDevice

DRIVER_ADD_DEVICE ClassAddDevice

static

Definition at line 26 of file kbdclass.c.

Referenced by _IRQL_requires_max_(), DriverEntry(), and SearchForLegacyDrivers().

ClassCancelRoutine

DRIVER_CANCEL ClassCancelRoutine

static

Definition at line 28 of file kbdclass.c.

Referenced by HandleReadIrp().

ClassCleanup

DRIVER_DISPATCH ClassCleanup

static

Definition at line 22 of file kbdclass.c.

Referenced by DriverEntry().

ClassClose

DRIVER_DISPATCH ClassClose

static

Definition at line 21 of file kbdclass.c.

Referenced by ClassCleanupAndFree(), ClassUnload(), DriverEntry(), and WdfRegisterClassLibrary().

ClassCreate

DRIVER_DISPATCH ClassCreate

static

Definition at line 20 of file kbdclass.c.

Referenced by DriverEntry(), ReferenceClassVersion(), and WdfRegisterClassLibrary().

ClassDeviceControl

DRIVER_DISPATCH ClassDeviceControl

static

Definition at line 24 of file kbdclass.c.

Referenced by DiskDeviceControl(), DriverEntry(), and ScsiFlopDeviceControl().

ClassPower

DRIVER_DISPATCH ClassPower

static

Definition at line 25 of file kbdclass.c.

Referenced by DriverEntry().

ClassRead

DRIVER_DISPATCH ClassRead

static

Definition at line 23 of file kbdclass.c.

Referenced by DriverEntry().

ClassStartIo

DRIVER_STARTIO ClassStartIo

static

Definition at line 27 of file kbdclass.c.

Referenced by DriverEntry().

DriverUnload

DRIVER_UNLOAD DriverUnload

static

Definition at line 19 of file kbdclass.c.

Referenced by _Function_class_(), and DriverEntry().