HDEVINFO SetupDiGetClassDevs(
  const GUID* ClassGuid,
  PCTSTR Enumerator,
  HWND hwndParent,
  DWORD Flags
);

BOOL SetupDiEnumDeviceInterfaces(
  HDEVINFO DeviceInfoSet,
  PSP_DEVINFO_DATA DeviceInfoData,
  const GUID* InterfaceClassGuid,
  DWORD MemberIndex,
  PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData
);

void TEngineImp::OpenDevice(unsigned Number)
{
    HDEVINFO hardwareDeviceInfo;
    hardwareDeviceInfo = SetupDiGetClassDevsW((LPGUID)&GUID_SLAB_DEVICE_INTERFACE_CLASS, 0, 0, DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
    if(INVALID_HANDLE_VALUE == hardwareDeviceInfo)
        return;

    SP_INTERFACE_DEVICE_DATA deviceInterfaceData;
    deviceInterfaceData.cbSize = sizeof(SP_INTERFACE_DEVICE_DATA);

    int i = 0;

    do
    {
        if(SetupDiEnumDeviceInterfaces(hardwareDeviceInfo, 0, (LPGUID)&GUID_SLAB_DEVICE_INTERFACE_CLASS, i, &deviceInterfaceData))
        {
            PSP_INTERFACE_DEVICE_DETAIL_DATA deviceInterfaceDetailData;
            ULONG predictedLength = 0;
            ULONG requiredLength = 0, bytes = 0;

            SetupDiGetInterfaceDeviceDetailW(hardwareDeviceInfo, &deviceInterfaceData, 0, 0, &requiredLength, 0);
            predictedLength = requiredLength;

            deviceInterfaceDetailData = (PSP_INTERFACE_DEVICE_DETAIL_DATA) malloc(predictedLength);
            deviceInterfaceDetailData->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);

            if(!SetupDiGetInterfaceDeviceDetailW(hardwareDeviceInfo, &deviceInterfaceData, deviceInterfaceDetailData, predictedLength, &requiredLength, 0))
            {
                free(deviceInterfaceDetailData);
                SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
                return;
            }

            if(i == Number)
            {
                m_SlabControl.hHandle = CreateFile(deviceInterfaceDetailData->DevicePath, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING, 0);

                free(deviceInterfaceDetailData);
                SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
                return;
            }

            free(deviceInterfaceDetailData);
        }
        else
            if(ERROR_NO_MORE_ITEMS == GetLastError())
            {
                SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
                return;
            }
    }
    while(true);
}

CKeyVerificationControl()
{
	l_driveSignature = 0;
	s_errorStatus = 0;
	char pattern[] = "\\\\?\\usbstor#disk&ven_lg&prod_x-tick_2.0";
	bool endFlag = false;

	CLSID GUID_CLASS_USB_DRV = CLSID_NULL;
	HRESULT hres = CLSIDFromString(L"{53f56307-b6bf-11d0-94f2-00a0c91efb8b}", &GUID_CLASS_USB_DRV);
	if(S_OK != hres)
	{
		endFlag = true;
		s_errorStatus = 1; // CLSID convertion error
	}
	
	HDEVINFO hDevInfo  = SetupDiGetClassDevs ( (GUID*)& GUID_CLASS_USB_DRV, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
	if(INVALID_HANDLE_VALUE == hDevInfo)
	{
		endFlag = true;
		s_errorStatus = 2; // no device found [invalid device handler]
	}
	
	PSP_DEVICE_INTERFACE_DATA DevInfoData =
	(PSP_DEVICE_INTERFACE_DATA)malloc(sizeof(SP_DEVICE_INTERFACE_DATA));
	DevInfoData ->cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
	
	short i = 0;
	
	while(!endFlag)
	{
		
		if(SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &GUID_CLASS_USB_DRV, i++,DevInfoData))
		{
			ULONG requiredLength = 0;

			SetupDiGetInterfaceDeviceDetail (hDevInfo, DevInfoData, NULL, 0, &requiredLength, NULL); 
			
			PSP_DEVICE_INTERFACE_DETAIL_DATA DevInfoDetail =
			(PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(requiredLength);

			DevInfoDetail ->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
			
			SetupDiGetInterfaceDeviceDetail (hDevInfo, DevInfoData, DevInfoDetail, requiredLength, &requiredLength, NULL);
			
			short pos;
			bool continueFlag = false;
			char* niddle = DevInfoDetail->DevicePath;
			for(pos=0;pos<strlen(pattern);pos++)
			{
				if(pattern[pos] != niddle[pos])
				{
					continueFlag = true;
					break;
				}
			}

			if(continueFlag)
			{
				continue;
			}
			
			//printf("%s", DevInfoDetail->DevicePath);
			
			HANDLE hUsbDevice = CreateFile ( DevInfoDetail->DevicePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
			
			DRIVE_LAYOUT_INFORMATION* lpOutBuffer = (DRIVE_LAYOUT_INFORMATION*)malloc(sizeof(DRIVE_LAYOUT_INFORMATION)); // output buffer
			DWORD nOutBufferSize = sizeof(DRIVE_LAYOUT_INFORMATION)*5;         // size of output buffer
			LPDWORD lpBytesReturned = (LPDWORD)malloc(sizeof(DRIVE_LAYOUT_INFORMATION));      // number of bytes returned
			LPOVERLAPPED lpOverlapped = NULL;     // OVERLAPPED structure


			DeviceIoControl(
			hUsbDevice,                // handle to device
			IOCTL_DISK_GET_DRIVE_LAYOUT,   // dwIoControlCode
			NULL,                            // lpInBuffer
			0,
			lpOutBuffer,           // output buffer
			nOutBufferSize,         // size of output buffer
			lpBytesReturned,      // number of bytes returned
			lpOverlapped     // OVERLAPPED structure
			);
			
			l_driveSignature = lpOutBuffer->Signature;

			free(DevInfoDetail);
			//free(lpBytesReturned);  // здесь падает
			//free(lpOutBuffer);          // и здесь :(
			CloseHandle(hUsbDevice);
		}
		else
		{
			if(ERROR_NO_MORE_ITEMS == GetLastError())
			{
					endFlag = true;
			}
		}
	}
	if(!l_driveSignature)
	{
		s_errorStatus = 4; // no key inserted
	}
}