mouse.c

winNT技术操作系统,国外开放的原代码和LIUX一样

{
    PDEVICE_OBJECT dev_obj;
    NTSTATUS status;
    PUSB_DEV pdev;
    PUSB_DRIVER pdrvr;

    if (dev_mgr == NULL || dev_handle == 0)
        return FALSE;

    pdev = NULL;
    //special use of the lock dev, simply use this routine to get the dev
    status = usb_query_and_lock_dev(dev_mgr, dev_handle, &pdev);
    if (pdev == NULL)
    {
        return FALSE;
    }
    if (status == STATUS_SUCCESS)
    {
        // must be a bug
        TRAP();
        usb_unlock_dev(pdev);
    }
    pdrvr = pdev->dev_driver;
    dev_obj = pdev->dev_obj;
    pdev = NULL;

    return TRUE;//umss_delete_device(dev_mgr, pdrvr, dev_obj, FALSE);
}

// Dispatch routine for our IRPs
NTSTATUS
MouseDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST;

    usb_dbg_print(DBGLVL_MAXIMUM, ("MouseDispatch(DO %p, code 0x%lx) called\n",
        DeviceObject,
        IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode));
#if 0
    if (DeviceObject == KeyboardFdo)
    {
        // it's keyboard's IOCTL
        PIO_STACK_LOCATION Stk;

        Irp->IoStatus.Information = 0;
        Stk = IoGetCurrentIrpStackLocation(Irp);

        switch (Stk->Parameters.DeviceIoControl.IoControlCode)
        {
        case IOCTL_INTERNAL_KEYBOARD_CONNECT:
            DPRINT("IOCTL_INTERNAL_KEYBOARD_CONNECT\n");
            if (Stk->Parameters.DeviceIoControl.InputBufferLength <	sizeof(DEV_CONNECT_DATA)) {
                DPRINT1("Keyboard IOCTL_INTERNAL_KEYBOARD_CONNECT "
                    "invalid buffer size\n");
                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                goto intcontfailure;
            }

            RtlCopyMemory(&KbdClassInformation,
                Stk->Parameters.DeviceIoControl.Type3InputBuffer,
                sizeof(DEV_CONNECT_DATA));

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;

        case IOCTL_INTERNAL_I8042_KEYBOARD_WRITE_BUFFER:
            DPRINT("IOCTL_INTERNAL_I8042_KEYBOARD_WRITE_BUFFER\n");
            if (Stk->Parameters.DeviceIoControl.InputBufferLength <	1) {
                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                goto intcontfailure;
            }
            /*			if (!DevExt->KeyboardInterruptObject) {
            Irp->IoStatus.Status = STATUS_DEVICE_NOT_READY;
            goto intcontfailure;
            }*/

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        case IOCTL_KEYBOARD_QUERY_ATTRIBUTES:
            DPRINT("IOCTL_KEYBOARD_QUERY_ATTRIBUTES\n");
            if (Stk->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(KEYBOARD_ATTRIBUTES)) {
                    DPRINT("Keyboard IOCTL_KEYBOARD_QUERY_ATTRIBUTES: "
                        "invalid buffer size\n");
                    Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                    goto intcontfailure;
            }
            /*RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
            &DevExt->KeyboardAttributes,
            sizeof(KEYBOARD_ATTRIBUTES));*/

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        case IOCTL_KEYBOARD_QUERY_INDICATORS:
            DPRINT("IOCTL_KEYBOARD_QUERY_INDICATORS\n");
            if (Stk->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(KEYBOARD_INDICATOR_PARAMETERS)) {
                    DPRINT("Keyboard IOCTL_KEYBOARD_QUERY_INDICATORS: "
                        "invalid buffer size\n");
                    Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                    goto intcontfailure;
            }
            /*RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
            &DevExt->KeyboardIndicators,
            sizeof(KEYBOARD_INDICATOR_PARAMETERS));*/

            Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_KEYBOARD_QUERY_TYPEMATIC:
            DPRINT("IOCTL_KEYBOARD_QUERY_TYPEMATIC\n");
            if (Stk->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(KEYBOARD_TYPEMATIC_PARAMETERS)) {
                    DPRINT("Keyboard IOCTL_KEYBOARD_QUERY_TYPEMATIC: "
                        "invalid buffer size\n");
                    Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                    goto intcontfailure;
            }
            /*RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
            &DevExt->KeyboardTypematic,
            sizeof(KEYBOARD_TYPEMATIC_PARAMETERS));*/

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        case IOCTL_KEYBOARD_SET_INDICATORS:
            DPRINT("IOCTL_KEYBOARD_SET_INDICATORS\n");
            if (Stk->Parameters.DeviceIoControl.InputBufferLength <
                sizeof(KEYBOARD_INDICATOR_PARAMETERS)) {
                    DPRINT("Keyboard IOCTL_KEYBOARD_SET_INDICTATORS: "
                        "invalid buffer size\n");
                    Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                    goto intcontfailure;
            }

            /*RtlCopyMemory(&DevExt->KeyboardIndicators,
            Irp->AssociatedIrp.SystemBuffer,
            sizeof(KEYBOARD_INDICATOR_PARAMETERS));*/

            //DPRINT("%x\n", DevExt->KeyboardIndicators.LedFlags);

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        case IOCTL_KEYBOARD_SET_TYPEMATIC:
            DPRINT("IOCTL_KEYBOARD_SET_TYPEMATIC\n");
            if (Stk->Parameters.DeviceIoControl.InputBufferLength <
                sizeof(KEYBOARD_TYPEMATIC_PARAMETERS)) {
                    DPRINT("Keyboard IOCTL_KEYBOARD_SET_TYPEMATIC "
                        "invalid buffer size\n");
                    Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                    goto intcontfailure;
            }

            /*RtlCopyMemory(&DevExt->KeyboardTypematic,
            Irp->AssociatedIrp.SystemBuffer,
            sizeof(KEYBOARD_TYPEMATIC_PARAMETERS));*/

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        case IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION:
            /* We should check the UnitID, but it's	kind of	pointless as
            * all keyboards are supposed to have the same one
            */
            /*RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
            &IndicatorTranslation,
            sizeof(LOCAL_KEYBOARD_INDICATOR_TRANSLATION));*/

            Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
            break;
        case IOCTL_INTERNAL_I8042_HOOK_KEYBOARD:
            /* Nothing to do here */
            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        default:
            Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
            break;
        }

intcontfailure:
        Status = Irp->IoStatus.Status;
    }
    else 
#endif
    if (DeviceObject == MouseFdo)
    {
        // it's mouse's IOCTL
        PIO_STACK_LOCATION Stk;

        Irp->IoStatus.Information = 0;
        Stk = IoGetCurrentIrpStackLocation(Irp);

        switch (Stk->Parameters.DeviceIoControl.IoControlCode)
        {
        case IOCTL_INTERNAL_MOUSE_CONNECT:
            usb_dbg_print(DBGLVL_MAXIMUM, ("IOCTL_INTERNAL_MOUSE_CONNECT\n"));
            if (Stk->Parameters.DeviceIoControl.InputBufferLength <	sizeof(CONNECT_DATA)) {
                usb_dbg_print(DBGLVL_MINIMUM, ("IOCTL_INTERNAL_MOUSE_CONNECT: "
                    "invalid buffer size\n"));
                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                goto intcontfailure2;
            }

            RtlCopyMemory(&MouseClassInformation,
                Stk->Parameters.DeviceIoControl.Type3InputBuffer,
                sizeof(CONNECT_DATA));

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;

        default:
            Irp->IoStatus.Status = STATUS_SUCCESS;//STATUS_INVALID_DEVICE_REQUEST;
            break;
        }
intcontfailure2:
        Status = Irp->IoStatus.Status;
    }

    if (Status == STATUS_INVALID_DEVICE_REQUEST)
    {
        usb_dbg_print(DBGLVL_MINIMUM, ("Invalid internal device request!\n"));
    }

    if (Status != STATUS_PENDING)
        IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return Status;
}

NTSTATUS
AddRegistryEntry(
                 IN PCWSTR PortTypeName,
                 IN PUNICODE_STRING DeviceName,
                 IN PCWSTR RegistryPath)
{
    UNICODE_STRING PathU = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\HARDWARE\\DEVICEMAP");
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hDeviceMapKey = (HANDLE)-1;
    HANDLE hPortKey = (HANDLE)-1;
    UNICODE_STRING PortTypeNameU;
    NTSTATUS Status;

    InitializeObjectAttributes(&ObjectAttributes, &PathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
    Status = ZwOpenKey(&hDeviceMapKey, 0, &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        usb_dbg_print(DBGLVL_MINIMUM, ("ZwOpenKey() failed with status 0x%08lx\n", Status));
        goto cleanup;
    }

    RtlInitUnicodeString(&PortTypeNameU, PortTypeName);
    InitializeObjectAttributes(&ObjectAttributes, &PortTypeNameU, OBJ_KERNEL_HANDLE, hDeviceMapKey, NULL);
    Status = ZwCreateKey(&hPortKey, KEY_SET_VALUE, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
    if (!NT_SUCCESS(Status))
    {
        usb_dbg_print(DBGLVL_MINIMUM, ("ZwCreateKey() failed with status 0x%08lx\n", Status));
        goto cleanup;
    }

    Status = ZwSetValueKey(hPortKey, DeviceName, 0, REG_SZ, (PVOID)RegistryPath, (ULONG)(wcslen(RegistryPath) * sizeof(WCHAR) + sizeof(UNICODE_NULL)));
    if (!NT_SUCCESS(Status))
    {
        usb_dbg_print(DBGLVL_MINIMUM, ("ZwSetValueKey() failed with status 0x%08lx\n", Status));
        goto cleanup;
    }

    Status = STATUS_SUCCESS;

cleanup:
    if (hDeviceMapKey != (HANDLE)-1)
        ZwClose(hDeviceMapKey);
    if (hPortKey != (HANDLE)-1)
        ZwClose(hPortKey);
    return Status;
}

static NTSTATUS
MouseCreateDevice(IN PDRIVER_OBJECT DriverObject)
{
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\PointerPortUSB");
    PDEVEXT_HEADER DeviceExtension;
    PDEVICE_OBJECT Fdo;
    NTSTATUS Status;

    Status = AddRegistryEntry(L"PointerPort", &DeviceName, L"REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services\\usbdriver");
    if (!NT_SUCCESS(Status))
    {
        usb_dbg_print(DBGLVL_MINIMUM, ("AddRegistryEntry() for usb mouse driver failed with status 0x%08lx\n", Status));
        return Status;
    }

    Status = IoCreateDevice(DriverObject,
        sizeof(DEVEXT_HEADER),
        &DeviceName,
        FILE_DEVICE_MOUSE,
        FILE_DEVICE_SECURE_OPEN,
        TRUE,
        &Fdo);

    if (!NT_SUCCESS(Status))
    {
        usb_dbg_print(DBGLVL_MINIMUM, ("IoCreateDevice() for usb mouse driver failed with status 0x%08lx\n", Status));
        return Status;
    }
    DeviceExtension = (PDEVEXT_HEADER)Fdo->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(DEVEXT_HEADER));

    DeviceExtension->dispatch = MouseDispatch;

    MouseFdo = Fdo;
    Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
    usb_dbg_print(DBGLVL_MEDIUM, ("Created mouse Fdo: %p\n", Fdo));

    return STATUS_SUCCESS;
}