Не удается найти указаный файл при попытке запуска драйвера

IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT PhysicalDeviceObject)
 
{
    NTSTATUS                           status;
    PDEVICE_OBJECT                 deviceObject;
    PDEVICE_OBJECT                 deviceObjectEXTRA;
    PDEVICE_EXTENSION           deviceExtension = NULL;
    PEXTRADEVICE_EXTENSION  EXTRAdeviceExtension = NULL;
 
    PAGED_CODE();
    
    // Создаем объект-фильтр устройства. 
    status = IoCreateDevice(
        DriverObject,
        sizeof(DEVICE_EXTENSION),
        NULL,                       // No Name
        FILE_DEVICE_UNKNOWN,
        FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
        FALSE,
        &deviceObject
        );
 
  status = IoCreateDevice(
        DriverObject,
        sizeof(EXTRAdeviceExtension),
        Name32,                      
        FILE_DEVICE_UNKNOWN,
        FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
        FALSE,
        &deviceObjectEXTRA
        );

typedef struct _DEVICE_EXTENSION
{
    int Tag;
    
    // ...
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
 
// ...
 
NTSTATUS
DriverDispatch(
    __in    DEVICE_OBJECT             * pDeviceObj,
    __in    IRP                       * pIrp
    )
{
    DEVICE_EXTENSION *pDeviceExt = pDeviceObj->DeviceExtension;
    
    switch (pDeviceExt->Tag)
    {
        case MY_FILTER_DEVICE:
        {
            // ...
        }
        break;
        
        case MY_CONTROL_DEVICE:
        {
            // ...
        }
        break;
    }
}

if (!NT_SUCCESS(edoStatus)) {
        KdPrint((edoStatus,"Oshibka sozdanija EDO\n" ));
        return edoStatus;
    }

//в заголовочном файле константы
#define FIDO_EXTENSION 0
#define EDO_EXTENSION  1
#define WIN32_DEVICE_NAME L"\\DosDevices\\mssnddv"
#define NT_DEVICE_NAME L"\\Device\\MyExtra%d"
//------------------------------------------------------------------
// LaserPU_AddDevice()
// Добавление драйвера в стек драйверов мыши
//------------------------------------------------------------------
NTSTATUS
LaserPUAddDevice(
    IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT PhysicalDeviceObject)
 
{
    NTSTATUS                status;
    PDEVICE_OBJECT          deviceObject;
    PDEVICE_EXTENSION       deviceExtension = NULL;
    UNICODE_STRING edonameLink;
    UNICODE_STRING edoname;
    PDEVICE_OBJECT          edo;
    NTSTATUS                             edoStatus;
    PEXTRA_DEVICE_EXTENSION ExtraDeviceExtension = NULL;
 
    PAGED_CODE();
    
    // Создаем объект-фильтр устройства. 
    status = IoCreateDevice(
        DriverObject,
        sizeof(DEVICE_EXTENSION),
        NULL,                       // No Name
        FILE_DEVICE_UNKNOWN,
        FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
        FALSE,
        &deviceObject
        );
 
    if (!NT_SUCCESS(status)) {
 
        //
        // Returning failure here prevents the entire stack from functioning,
        // but most likely the rest of the stack will not be able to create
        // device objects either, so it is still OK.
        //
        return status;
    }
 
    KdPrint((
        "AddDevice PDO (0x%x) FDO (0x%x)\n",
        PhysicalDeviceObject,
        deviceObject
        ));
 
    // Получаем указатель на расширение нашего устройства.
    deviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
 
    // Сохраняю для дальнейшего использования.
    deviceExtension->Self = deviceObject;
    deviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
 
    // Создаем объект устройства, находящегося в данный момент на вершине стека;
    // Сохраняем указатель на него и подключаем фильтр к вершине стека.
    deviceExtension->NextLowerDriver = IoAttachDeviceToDeviceStack(
        deviceObject,
        PhysicalDeviceObject
        );
 
    // Если не подсоединился - проблема в PnP, удалить объект устройства
    if (NULL == deviceExtension->NextLowerDriver) {
        IoDeleteDevice(deviceObject);
        return STATUS_UNSUCCESSFUL;
    }
 
    // Копирование флагов устройства из устройства ниже по стеку.
    deviceObject->Flags |= deviceExtension->NextLowerDriver->Flags &
                            (DO_BUFFERED_IO | DO_DIRECT_IO |
                            DO_POWER_PAGABLE  | DO_POWER_INRUSH);
 
    deviceObject->DeviceType = deviceExtension->NextLowerDriver->DeviceType;
 
    deviceObject->Characteristics =
                          deviceExtension->NextLowerDriver->Characteristics;
 
    // Инициализирование состояния устройства.   
    INITIALIZE_PNP_STATE(deviceExtension);
 
 
    IoInitializeRemoveLock (&deviceExtension->RemoveLock , 
                            POOL_TAG,
                            1, // MaxLockedMinutes 
                            5); // HighWatermark, this parameter is 
                                // used only on checked build.
                                
    KdPrint((
        "AddDevice: %x to %x->%x \n",
        deviceObject,
        deviceExtension->NextLowerDriver,
        PhysicalDeviceObject
        ));
 
    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
    //добавим объект "сбоку"
    deviceExtension->flag = FIDO_EXTENSION;
   
   //создание имени в правильном формате ++
    RtlInitUnicodeString(&edoname,NT_DEVICE_NAME);
    //создание имени в правильном формате --
    //win32  имя в правильном формате
     RtlInitUnicodeString(&edonameLink,WIN32_DEVICE_NAME);
    //win32  имя в правильном формате--
    
    
    
    edoStatus = IoCreateDevice(DriverObject,sizeof(EXTRA_DEVICE_EXTENSION) ,    &edoname,FILE_DEVICE_UNKNOWN,0,FALSE,&edo);
    
     if (!NT_SUCCESS(edoStatus)) {
        KdPrint((edoStatus,"Oshibka sozdanija EDO\n" ));
        return edoStatus;
    }
    
    ExtraDeviceExtension = (PEXTRA_DEVICE_EXTENSION) edo->DeviceExtension;  
    ExtraDeviceExtension->flag = EDO_EXTENSION;
    ExtraDeviceExtension->pdx = deviceExtension;
    deviceExtension->edx = ExtraDeviceExtension;
    
     edoStatus =   IoCreateSymbolicLink(&edonameLink,&edoname);//создаем линк между нт и вин32 именами
      if (!NT_SUCCESS(edoStatus)) {
        KdPrint(("Oshibka sozdanija Linka\n" ,edoStatus));
        IoDeleteDevice(edo);
        return edoStatus;
    }
 
    return STATUS_SUCCESS;
}

KdPrint(("Can't create EDO (status = 0x%.8lx).\r\n", edoStatus));

/*++
#include "LaserPU.h"
 
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#pragma alloc_text(PAGE, LaserPUAddDevice)
#pragma alloc_text(PAGE, LaserPUUnload)
#pragma alloc_text(PAGE, LaserPUDispatchPnp)
#pragma alloc_text(PAGE, LaserPUDispatchPower)
#endif
 
//------------------------------------------------------------------
// DriverEntry()
// Инициализация драйвера при установке
//------------------------------------------------------------------
NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath)
 
{
    USHORT              regPathLen;
    ULONG               ulIndex;
    PDRIVER_DISPATCH  * dispatch;
 
    KdPrint(("Entered the Driver Entry\n"));
 
    // Заполняю массив главных функций указателем на функцию,
    // пропускающую пакеты вниз по стеку.
    for (ulIndex = 0, dispatch = DriverObject->MajorFunction;
         ulIndex <= IRP_MJ_MAXIMUM_FUNCTION;
         ulIndex++, dispatch++) {
 
        *dispatch = LaserPU_DispatchPassThrough;
    }
 
    // Обновляю указатели на используемые объекты
    DriverObject->MajorFunction[IRP_MJ_PNP]                         = LaserPUDispatchPnp;
    DriverObject->MajorFunction[IRP_MJ_POWER]                       = LaserPUDispatchPower;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL]     = LaserPU_DispatchDeviceControl;
     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]     =  LaserPU_DispatchIODeviceControl; //тут  мы должны вызывать колбек оригинальный
    DriverObject->DriverExtension->AddDevice                        = LaserPUAddDevice;
    DriverObject->DriverUnload                                      = LaserPUUnload;
 
    return STATUS_SUCCESS;
}
 
//------------------------------------------------------------------
// LaserPU_AddDevice()
// Добавление драйвера в стек драйверов мыши
//------------------------------------------------------------------
NTSTATUS
LaserPUAddDevice(
    IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT PhysicalDeviceObject)
 
{
    NTSTATUS                status;
    PDEVICE_OBJECT          deviceObject;
    PDEVICE_EXTENSION       deviceExtension = NULL;
     UNICODE_STRING edonameLink;
    UNICODE_STRING edoname;
    PDEVICE_OBJECT          edo;
    NTSTATUS                             edoStatus;
    PDEVICE_EXTENSION ExtraDeviceExtension = NULL;
 
    PAGED_CODE();
    
    // Создаем объект-фильтр устройства. 
    status = IoCreateDevice(
        DriverObject,
        sizeof(DEVICE_EXTENSION),
        NULL,                       // No Name
        FILE_DEVICE_UNKNOWN,
        FILE_DEVICE_SECURE_OPEN | FILE_AUTOGENERATED_DEVICE_NAME,
        FALSE,
        &deviceObject
        );
 
    if (!NT_SUCCESS(status)) {
 
        //
        // Returning failure here prevents the entire stack from functioning,
        // but most likely the rest of the stack will not be able to create
        // device objects either, so it is still OK.
        //
        return status;
    }
 
    KdPrint((
        "AddDevice PDO (0x%x) FDO (0x%x)\n",
        PhysicalDeviceObject,
        deviceObject
        ));
 
    // Получаем указатель на расширение нашего устройства.
    deviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
    
    deviceExtension->flag = FIDO_EXTENSION;
 
    // Сохраняю для дальнейшего использования.
    deviceExtension->Self = deviceObject;
    deviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
 
    // Создаем объект устройства, находящегося в данный момент на вершине стека;
    // Сохраняем указатель на него и подключаем фильтр к вершине стека.
    deviceExtension->NextLowerDriver = IoAttachDeviceToDeviceStack(
        deviceObject,
        PhysicalDeviceObject
        );
 
    // Если не подсоединился - проблема в PnP, удалить объект устройства
    if (NULL == deviceExtension->NextLowerDriver) {
        IoDeleteDevice(deviceObject);
        return STATUS_UNSUCCESSFUL;
    }
 
    // Копирование флагов устройства из устройства ниже по стеку.
    deviceObject->Flags |= deviceExtension->NextLowerDriver->Flags &
                            (DO_BUFFERED_IO | DO_DIRECT_IO |
                            DO_POWER_PAGABLE  | DO_POWER_INRUSH);
 
    deviceObject->DeviceType = deviceExtension->NextLowerDriver->DeviceType;
 
    deviceObject->Characteristics =
                          deviceExtension->NextLowerDriver->Characteristics;
 
    // Инициализирование состояния устройства.   
    INITIALIZE_PNP_STATE(deviceExtension);
 
 
    IoInitializeRemoveLock (&deviceExtension->RemoveLock , 
                            POOL_TAG,
                            1, // MaxLockedMinutes 
                            5); // HighWatermark, this parameter is 
                                // used only on checked build.
                                
    KdPrint((
        "AddDevice: %x to %x->%x \n",
        deviceObject,
        deviceExtension->NextLowerDriver,
        PhysicalDeviceObject
        ));
 
    deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
    //добавим объект "сбоку"
    
   
   //создание имени в правильном формате ++
    RtlInitUnicodeString(&edoname,NT_DEVICE_NAME);
    //создание имени в правильном формате --
    //win32  имя в правильном формате
     RtlInitUnicodeString(&edonameLink,WIN32_DEVICE_NAME);
    //win32  имя в правильном формате--
    
    
    //edoStatus = IoCreateDevice(DriverObject,sizeof(EXTRA_DEVICE_EXTENSION) ,  &edoname,FILE_DEVICE_UNKNOWN,FILE_DEVICE_SECURE_OPEN,FALSE,&edo);
    edoStatus = IoCreateDevice(DriverObject,sizeof(DEVICE_EXTENSION)  , &edoname,FILE_DEVICE_UNKNOWN,FILE_DEVICE_SECURE_OPEN,FALSE,&edo);
    
     if (!NT_SUCCESS(edoStatus)) {
        KdPrint((edoStatus,"Oshibka sozdanija EDO\n" ));
        return edoStatus;
    }
    
       ExtraDeviceExtension = (PDEVICE_EXTENSION) edo->DeviceExtension; 
       ExtraDeviceExtension->flag = EDO_EXTENSION;
       ExtraDeviceExtension->pdx = deviceExtension;
      //deviceExtension->edx = ExtraDeviceExtension;
    
     edoStatus =   IoCreateSymbolicLink(&edonameLink,&edoname);//создаем линк между нт и вин32 именами
      if (!NT_SUCCESS(edoStatus)) {
        KdPrint(("Oshibka sozdanija Linka\n" ,edoStatus));
        IoDeleteDevice(edo);
       return edoStatus;
       }
 
 
 
    return STATUS_SUCCESS;
}
 
 
//---------------------------------------------------------------------
// LaserPU_Unload()
// Выгрузка драйвера
//---------------------------------------------------------------------
VOID
LaserPUUnload(
    IN PDRIVER_OBJECT DriverObject
    )
 
{
    PAGED_CODE();
 
    ASSERT(DriverObject->DeviceObject == NULL);
    DriverObject->DeviceObject->NextDevice;
    ASSERT(DriverObject->DeviceObject == NULL);
 
    KdPrint(("unload\n"));
 
    return;
}
 
 
//-------------------------------------------------------------------
// LaserPU_DispatchPnp()
// Обработка PnP пакетов. Мы обрабатываем PnP пакеты, чтобы вовремя отсоединиться
//-------------------------------------------------------------------
NTSTATUS
LaserPUDispatchPnp(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp)
 
{
    PDEVICE_EXTENSION           deviceExtension;
    PIO_STACK_LOCATION          irpStack, nextStack;
    NTSTATUS                    status;
    KEVENT                      event;
 
    PAGED_CODE();
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    // Получить ячейку стека для нашего драйвера.
    irpStack = IoGetCurrentIrpStackLocation(Irp);
 
   status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
    if (!NT_SUCCESS (status)) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
    
    // Просмотр доп. функции в пакете.
    switch(irpStack->MinorFunction) {
 
    case IRP_MN_START_DEVICE:
 
        // Драйвер стартует.
        // Нельзя работать с драйвером, пока пакет не обработается 
        // всеми драйверами стека.
        KeInitializeEvent(&event,
                          NotificationEvent,
                          FALSE
                          );
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        IoSetCompletionRoutine(
            Irp,
            LaserPU_CompleteIRP,
            &event,
            TRUE,
            TRUE,
            TRUE
            );
 
        status = IoCallDriver(deviceExtension->NextLowerDriver, Irp);
 
        if (STATUS_PENDING == status) {
 
            KeWaitForSingleObject(
               &event,
               Executive, // Waiting for reason of a driver
               KernelMode, // Waiting in kernel mode
               FALSE, // No alert
               NULL // No timeout
               );
 
            status = Irp->IoStatus.Status;
        }
 
        if (NT_SUCCESS(status)) {
            
            // Устройство стартовало.
            SET_NEW_PNP_STATE(deviceExtension, Started);
        }
 
        //
        // We must now complete the IRP, since we stopped it in the
        // completion routine with STATUS_MORE_PROCESSING_REQUIRED.
        //
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
        return status;
 
    case IRP_MN_REMOVE_DEVICE:
 
        SET_NEW_PNP_STATE(deviceExtension, Deleted);
 
        //
        // Wait for all outstanding requests to complete
        //
        KdPrint(("Waiting for outstanding requests\n"));
        IoReleaseRemoveLockAndWait(&deviceExtension->RemoveLock, Irp);
        
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->NextLowerDriver, Irp);
 
        IoDetachDevice(deviceExtension->NextLowerDriver);
        IoDeleteDevice(DeviceObject);
        return status;
 
    case IRP_MN_QUERY_STOP_DEVICE:
        SET_NEW_PNP_STATE(deviceExtension, StopPending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_CANCEL_STOP_DEVICE:
 
        //
        // Check to see whether you have received cancel-stop
        // without first receiving a query-stop. This could happen if someone
        // above us fails a query-stop and passes down the subsequent
        // cancel-stop.
        //
 
        if(StopPending == deviceExtension->DevicePnPState)
        {
            //
            // We did receive a query-stop, so restore.
            //
            RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
        }
        status = STATUS_SUCCESS; // We must not fail this IRP.
        break;
 
    case IRP_MN_STOP_DEVICE:
        SET_NEW_PNP_STATE(deviceExtension, StopPending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_QUERY_REMOVE_DEVICE:
 
        SET_NEW_PNP_STATE(deviceExtension, RemovePending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_SURPRISE_REMOVAL:
 
        SET_NEW_PNP_STATE(deviceExtension, SurpriseRemovePending);
        status = STATUS_SUCCESS;
        break;
 
    case IRP_MN_CANCEL_REMOVE_DEVICE:
 
        //
        // Check to see whether you have received cancel-remove
        // without first receiving a query-remove. This could happen if
        // someone above us fails a query-remove and passes down the
        // subsequent cancel-remove.
        //
        if (RemovePending == deviceExtension->DevicePnPState) {
 
            //
            // We did receive a query-remove, so restore.
            //
            RESTORE_PREVIOUS_PNP_STATE(deviceExtension);
        }
 
        status = STATUS_SUCCESS; // We must not fail this IRP.
        break;
 
    default:
 
        //
        // If you don't handle any IRP you must leave the
        // status as is.
        //
        status = Irp->IoStatus.Status;
        break;
    }
 
    //
    // Pass the IRP down and forget it.
    //
    Irp->IoStatus.Status = status;
    IoSkipCurrentIrpStackLocation (Irp);
    status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
    IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
    return status;
}
 
//---------------------------------------------------------------------
// LaserPU_CompleteIRP()
// Позволяет драйверу посылать IRP вниз по стеку, отлавливать их на обратном пути
// (используется в LaserPU_DispatchPnp)
//---------------------------------------------------------------------
NTSTATUS
LaserPU_CompleteIRP(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN PVOID            Context)
 
{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    //
    // We could switch on the major and minor functions of the IRP to perform
    // different functions, but we know that Context is an event that needs
    // to be set.
    //
    KeSetEvent((PKEVENT) Context, IO_NO_INCREMENT, FALSE);
 
    //
    // Allows the caller to use the IRP after it is completed
    //
    return STATUS_MORE_PROCESSING_REQUIRED;
}
 
//---------------------------------------------------------------------
// LaserPU_DispatchPower()
// Управление энергопотреблением
//---------------------------------------------------------------------
NTSTATUS
LaserPUDispatchPower(
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp)
 
{
    PDEVICE_EXTENSION deviceExtension;
    NTSTATUS status;
    
    PAGED_CODE();
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
    if (!NT_SUCCESS (status)) { // may be device is being removed.
        Irp->IoStatus.Status = status;
        PoStartNextPowerIrp(Irp);
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
 
    PoStartNextPowerIrp(Irp);
 
    IoSkipCurrentIrpStackLocation(Irp);
    status =  PoCallDriver(deviceExtension->NextLowerDriver, Irp);
    IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
    return status;
    
}
 
//---------------------------------------------------------------------
// LaserPU_DispatchPassThrough()
// Функция, пропускающая пакеты, которые мы не обрабатываем
//---------------------------------------------------------------------
NTSTATUS
LaserPU_DispatchPassThrough(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp)
 
{
    PDEVICE_EXTENSION deviceExtension;
    NTSTATUS status;
    
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    
    if (!(deviceExtension->flag == FIDO_EXTENSION)) 
   {
     KdPrint(( "ne tot object v PassThrough\n"));
     return STATUS_SUCCESS;
   }
 
    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
    if (!NT_SUCCESS (status)) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
    
   IoSkipCurrentIrpStackLocation (Irp);
   status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
   IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
   return status;
   
}
 
//---------------------------------------------------------------------
// LaserPU_DispatchIODeviceControl()
// В данной функции мы должны получить вызов от приложения и вызвать колбек от низлежащего по стеку устройсва
// который в свою очередь должен вызвать LaserPU_ServiceCallback нашего устройства, подключенного к стеку
//---------------------------------------------------------------------
NTSTATUS LaserPU_DispatchIODeviceControl(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )
{ 
     PDEVICE_EXTENSION deviceExtension;
    PIO_STACK_LOCATION          irpStack;
    NTSTATUS                    status;
     KdPrint(( "Mi Vizvalis iz prilogenija\n"));
    //return STATUS_SHARING_VIOLATION;
    
     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    if (!(deviceExtension->flag ==  EDO_EXTENSION)) 
    {
      KdPrint(( "ne tot object  IO\n"));
      return STATUS_SUCCESS;
    }
     
     irpStack = IoGetCurrentIrpStackLocation(Irp);
  
   switch (irpStack->Parameters.DeviceIoControl.IoControlCode)
   {
    case IOCTL_TEST_MyMy:
        KdPrint(( "Mi poluchili ioctl\n"));
         //status = STATUS_SUCCESS;
        //Irp->IoStatus.Status = status;
         //IoCompleteRequest (Irp, IO_NO_INCREMENT);
   
   }
   
   return STATUS_SUCCESS;
    
}

//---------------------------------------------------------------------
// LaserPU_DispatchDeviceControl()
// В данной функции подсоединяемся к очереди пакетов Mouclass для их фильтрации
// Для этого регистрируется сервис возврата LaserPU_ServiceCallback
//---------------------------------------------------------------------
NTSTATUS
LaserPU_DispatchDeviceControl(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )
{
    PDEVICE_EXTENSION deviceExtension;
    PIO_STACK_LOCATION          irpStack;
    PCONNECT_DATA               connectData;
    NTSTATUS                    status;
 
    KdPrint(( "Wot i sluchilos DispatchDeviceControl\n"));
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    
    if (!(deviceExtension->flag == FIDO_EXTENSION)) 
   {
     KdPrint(( "ne tot object v devaice control\n"));
     return STATUS_SUCCESS;
   }
    
    Irp->IoStatus.Information = 0;
    irpStack = IoGetCurrentIrpStackLocation(Irp);
        
    status = IoAcquireRemoveLock (&deviceExtension->RemoveLock, Irp);
 
    if (!NT_SUCCESS (status)) {
        Irp->IoStatus.Status = status;
        IoCompleteRequest (Irp, IO_NO_INCREMENT);
        return status;
    }
    
    // Подключение классового драйвера к драйверу порта
    if (irpStack->Parameters.DeviceIoControl.IoControlCode ==
                        IOCTL_INTERNAL_MOUSE_CONNECT) {
 
        // Допустимо только одно подключение
        if (deviceExtension->UpperConnectData.ClassService != NULL) {
            return STATUS_SHARING_VIOLATION;
        }
        
        if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                        sizeof(CONNECT_DATA)) {
        
        // Недопустимый буфер
            return STATUS_INVALID_PARAMETER;
        }
        
        // Копируем параметры в расширение устройства
        connectData = ((PCONNECT_DATA)
            (irpStack->Parameters.DeviceIoControl.Type3InputBuffer));
 
        deviceExtension->UpperConnectData = *connectData;
 
        // Подключаюсь к очереди пакетов.
        // Как только появится пакет, адресованный системе - 
        // вызов LaserPU_ServiceCallback
        connectData->ClassDeviceObject = deviceExtension->Self;
        connectData->ClassService = LaserPU_ServiceCallback;
    }
 
    if (irpStack->Parameters.DeviceIoControl.IoControlCode == 
                        IOCTL_INTERNAL_MOUSE_DISCONNECT) {
 
        // Очистка параметров соединения в расширении устройства
        deviceExtension->UpperConnectData.ClassDeviceObject = NULL;
        deviceExtension->UpperConnectData.ClassService = NULL;
 
        status = STATUS_NOT_IMPLEMENTED;
        }
            
   IoSkipCurrentIrpStackLocation (Irp);
   status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
   IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
   return status;
}
 
 
//---------------------------------------------------------------------
// LaserPU_ServiceCallback()
// В данную функцию собственно передается управление при возникновении
// события от мыши. Передачу управления производит менеджер ввода\вывода
// когда Mouclass заполнит внутреннюю очередь пакетов.
//---------------------------------------------------------------------
VOID
LaserPU_ServiceCallback(
    IN PDEVICE_OBJECT DeviceObject,
    IN PMOUSE_INPUT_DATA InputDataStart,
    IN PMOUSE_INPUT_DATA InputDataEnd,
    IN OUT PULONG InputDataConsumed
    )
 
{
    PDEVICE_EXTENSION deviceExtension;
    PIO_STACK_LOCATION          irpStack;
    PCONNECT_DATA               connectData;
    PMOUSE_INPUT_DATA           MouseInputData;
    NTSTATUS                    status;
    
    int num;
    int i;
 
    KdPrint(( "Entered LaserPU_ServiceCallback\n"));
        
 
    deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 
    //
    // UpperConnectData must be called at DISPATCH
    //
 
    for (MouseInputData = InputDataStart;
         MouseInputData < InputDataEnd;
         MouseInputData++) 
    {
 
        //MouseInputData->LastX = 0x0;
      //  MouseInputData->LastY = 0x0;
 
        // обработка нажатия левой и правой кнопок мыши
        // если левая кнопка - текст вниз, правая - текст вверх
        // в противном случае - очистка событий
        
        if (MouseInputData->ButtonFlags == MOUSE_LEFT_BUTTON_DOWN)
                {
                //MouseInputData->ButtonFlags = 0x400;              
                //MouseInputData -> ButtonData  = 0x78; 
                KdPrint(( "LB\n"));
                }
            else if (InputDataStart->ButtonFlags == MOUSE_RIGHT_BUTTON_DOWN)
                {
                //MouseInputData->ButtonFlags = 0x400;              
                //MouseInputData -> ButtonData  = 0xff88;   
                KdPrint(( "RB\n"));
                }
            else
                {
                //MouseInputData->ButtonFlags = 0x0;
                }
    }
 
 
    (*(PSERVICE_CALLBACK_ROUTINE) deviceExtension->UpperConnectData.ClassService)(
        deviceExtension->UpperConnectData.ClassDeviceObject,
        InputDataStart,
        InputDataEnd,
        InputDataConsumed
        );
    return;
}

/*++
 
Copyright (c) Microsoft Corporation.  All rights reserved.
 
    THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
    KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
    PURPOSE.
 
 
Module Name:
 
    LaserPU.h
 
Abstract:
 
    This is the header for the Windows Driver Framework version
    of the firefly filter driver.
 
Environment:
 
    Kernel mode
 
--*/
 
#include <ntddk.h>
#include <wdf.h>
#define NTSTRSAFE_LIB
#include <ntstrsafe.h>
#include <initguid.h>
#include <wdmguid.h>
#include <ntddmou.h>
 
//
// Our drivers generated include from firefly.mof
// See makefile.inc for wmi commands
//
//#include "fireflymof.h"
 
// Our drivers modules includes
//#include "filter.h"
//#include "wmi.h"
//#include "vfeature.h"
//#include "magic.h"
 
//
// WDFDRIVER Object Events
//
#define IOCTL_TEST_MyMy CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800,METHOD_NEITHER,FILE_ANY_ACCESS)
#define IOCTL_INTERNAL_MOUSE_CONNECT    CTL_CODE(FILE_DEVICE_MOUSE, 0x0080, METHOD_NEITHER, FILE_ANY_ACCESS)
#define IOCTL_INTERNAL_MOUSE_DISCONNECT CTL_CODE(FILE_DEVICE_MOUSE, 0x0100, METHOD_NEITHER, FILE_ANY_ACCESS)
#define IOCTL_INTERNAL_MOUSE_ENABLE     CTL_CODE(FILE_DEVICE_MOUSE, 0x0200, METHOD_NEITHER, FILE_ANY_ACCESS)
#define IOCTL_INTERNAL_MOUSE_DISABLE    CTL_CODE(FILE_DEVICE_MOUSE, 0x0400, METHOD_NEITHER, FILE_ANY_ACCESS)
 
 
 
#define POOL_TAG   'liFT'
 
//
// These are the states Filter transition to upon
// receiving a specific PnP Irp. Refer to the PnP Device States
// diagram in DDK documentation for better understanding.
//
typedef struct _CONNECT_DATA {
    IN PDEVICE_OBJECT ClassDeviceObject;
    IN PVOID ClassService;
} CONNECT_DATA, *PCONNECT_DATA;
 
typedef
VOID
(*PSERVICE_CALLBACK_ROUTINE) (
    IN PVOID NormalContext,
   IN PVOID SystemArgument1,
   IN PVOID SystemArgument2,
   IN OUT PVOID SystemArgument3 );
 
typedef enum _DEVICE_PNP_STATE {
 
    NotStarted = 0,         // Not started yet
    Started,                // Device has received the START_DEVICE IRP
    StopPending,            // Device has received the QUERY_STOP IRP
    Stopped,                // Device has received the STOP_DEVICE IRP
    RemovePending,          // Device has received the QUERY_REMOVE IRP
    SurpriseRemovePending,  // Device has received the SURPRISE_REMOVE IRP
    Deleted                 // Device has received the REMOVE_DEVICE IRP
 
} DEVICE_PNP_STATE;
 
#define INITIALIZE_PNP_STATE(_Data_)    \
        (_Data_)->DevicePnPState =  NotStarted;\
        (_Data_)->PreviousPnPState = NotStarted;
 
#define SET_NEW_PNP_STATE(_Data_, _state_) \
        (_Data_)->PreviousPnPState =  (_Data_)->DevicePnPState;\
        (_Data_)->DevicePnPState = (_state_);
 
#define RESTORE_PREVIOUS_PNP_STATE(_Data_)   \
        (_Data_)->DevicePnPState =   (_Data_)->PreviousPnPState;\
 
typedef enum _DEVICE_TYPE {
 
    DEVICE_TYPE_INVALID = 0,         // Invalid Type;
    DEVICE_TYPE_FIDO,                // Device is a filter device.
    DEVICE_TYPE_CDO,                 // Device is a control device.
 
} DEVICE_TYPE;
 
#define FIDO_EXTENSION 0
#define EDO_EXTENSION  1
#define WIN32_DEVICE_NAME L"\\DosDevices\\mssnddv"
#define NT_DEVICE_NAME L"\\Device\\MyExtra%d"
 
 
 
 
 
 
 
typedef struct _COMMON_DEVICE_DATA
{
 
    DEVICE_TYPE Type;
 
} COMMON_DEVICE_DATA, *PCOMMON_DEVICE_DATA;
 
 
typedef struct _DEVICE_EXTENSION 
{
    ULONG flag;
    //struct _DEVICE_EXTENSION*  edx;//в девайс экстеншне основном ссылка на  дополнительный  девайс экстеншн
    struct _DEVICE_EXTENSION*  pdx;
    
    COMMON_DEVICE_DATA Common;
    
    
    //
    // A back pointer to the device object.
    //
    PDEVICE_OBJECT  PhysicalDeviceObject;
 
    PDEVICE_OBJECT  Self;
 
    //
    // The top of the stack before this filter was added.
    //
 
    PDEVICE_OBJECT  NextLowerDriver;
 
    //
    // current PnP state of the device
    //
 
    DEVICE_PNP_STATE  DevicePnPState;
 
    //
    // Remembers the previous pnp state
    //
 
    DEVICE_PNP_STATE    PreviousPnPState;
 
    //
    // Removelock to track IRPs so that device can be removed and
    // the driver can be unloaded safely.
    //
    IO_REMOVE_LOCK RemoveLock;
 
    CONNECT_DATA UpperConnectData;
 
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
 
typedef struct _EXTRA_DEVICE_EXTENSION 
{
    ULONG flag;
    PDEVICE_EXTENSION* pdx; //в девайс екстенсион доп объекта ссылка на основной объект
    PDEVICE_OBJECT  Self;
} EXTRA_DEVICE_EXTENSION, *PEXTRA_DEVICE_EXTENSION;
//
 
NTSTATUS DriverEntry(IN PDRIVER_OBJECT  DriverObject, IN PUNICODE_STRING RegistryPath);
NTSTATUS LaserPUAddDevice(IN PDRIVER_OBJECT DriverObject,IN PDEVICE_OBJECT PhysicalDeviceObject);
VOID LaserPUUnload(IN PDRIVER_OBJECT DriverObject);
NTSTATUS LaserPUDispatchPnp(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp);
NTSTATUS LaserPU_CompleteIRP(IN PDEVICE_OBJECT   DeviceObject, IN PIRP Irp, IN PVOID Context);
NTSTATUS LaserPUDispatchPower(IN PDEVICE_OBJECT    DeviceObject, IN PIRP Irp);
NTSTATUS LaserPU_DispatchDeviceControl(IN PDEVICE_OBJECT   DeviceObject, IN PIRP  Irp);
NTSTATUS LaserPU_DispatchIODeviceControl(IN PDEVICE_OBJECT   DeviceObject, IN PIRP Irp);
NTSTATUS LaserPU_DispatchPassThrough(IN PDEVICE_OBJECT   DeviceObject, IN PIRP    Irp);
VOID
LaserPU_ServiceCallback(
    IN PDEVICE_OBJECT DeviceObject,
    IN PMOUSE_INPUT_DATA InputDataStart,
    IN PMOUSE_INPUT_DATA InputDataEnd,
    IN OUT PULONG InputDataConsumed
    );
 
DRIVER_INITIALIZE DriverEntry;

NTSTATUS LaserPU_DispatchIODeviceControl(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp
    )
{ 
     PDEVICE_EXTENSION deviceExtension;
    PIO_STACK_LOCATION          irpStack;
    NTSTATUS                    status;
     KdPrint(( "Mi Vizvalis iz prilogenija\n"));
    //return STATUS_SHARING_VIOLATION;
    
     deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
    if (!(deviceExtension->flag ==  EDO_EXTENSION)) 
    {
      KdPrint(( "ne tot object  IO\n"));
      IoSkipCurrentIrpStackLocation (Irp);
     status = IoCallDriver (deviceExtension->NextLowerDriver, Irp);
        // IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp); 
      return status;
    }
     
     irpStack = IoGetCurrentIrpStackLocation(Irp);
  
   switch (irpStack->Parameters.DeviceIoControl.IoControlCode)
   {
    //case IOCTL_TEST_MyMy:
        KdPrint(( "Mi poluchili ioctl\n",irpStack->Parameters.DeviceIoControl.IoControlCode));
   
   }
   
   Irp->IoStatus.Status=STATUS_SUCCESS;
    IoCompleteRequest (Irp,IO_NO_INCREMENT); 
    return STATUS_SUCCESS;
    
}