void nRF5xCharacteristicDescriptorDiscoverer::terminate(Discovery* discovery, ble_error_t err) { // temporary copy, user code can try to launch a new discovery in the onTerminate // callback. So, this discovery should not appear in such case. Discovery tmp = *discovery; *discovery = Discovery(); tmp.terminate(err); }
ble_error_t nRF5xCharacteristicDescriptorDiscoverer::launch( const DiscoveredCharacteristic& characteristic, const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& discoveryCallback, const CharacteristicDescriptorDiscovery::TerminationCallback_t& terminationCallback ) { Gap::Handle_t connHandle = characteristic.getConnectionHandle(); // it is ok to deduce that the start handle for descriptors is after // the characteristic declaration and the characteristic value declaration // see BLUETOOTH SPECIFICATION Version 4.2 [Vol 3, Part G] (3.3) Gap::Handle_t descriptorStartHandle = characteristic.getDeclHandle() + 2; Gap::Handle_t descriptorEndHandle = characteristic.getLastHandle(); // check if there is any descriptor to discover if (descriptorEndHandle < descriptorStartHandle) { CharacteristicDescriptorDiscovery::TerminationCallbackParams_t termParams = { characteristic, BLE_ERROR_NONE }; terminationCallback.call(&termParams); return BLE_ERROR_NONE; } // check if we can run this discovery if (isConnectionInUse(connHandle)) { return BLE_STACK_BUSY; } // get a new discovery slot, if none are available, just return Discovery* discovery = getAvailableDiscoverySlot(); if(discovery == NULL) { return BLE_STACK_BUSY; } // try to launch the discovery ble_error_t err = gattc_descriptors_discover(connHandle, descriptorStartHandle, descriptorEndHandle); if(!err) { // commit the new discovery to its slot *discovery = Discovery(characteristic, discoveryCallback, terminationCallback); } return err; }
BOOL CNdasDevice::GetDeviceInfo( const LPX_ADDRESS& localAddress, const LPX_ADDRESS& remoteAddress, UCHAR ucType, UCHAR ucVersion) { ximeta::CAutoLock autolock(this); // // Get Device Information // LANSCSI_PATH lspath = {0}; // Discover does not need any user id lspath.iUserID = 0x0000; lspath.iPassword = GetHWPassword(); lspath.HWType = ucType; lspath.HWVersion = ucVersion; lspath.HWProtoType = ucType; lspath.HWProtoVersion = (LANSCSIIDE_VERSION_1_1 == ucVersion) ? LSIDEPROTO_VERSION_1_1 : LSIDEPROTO_VERSION_1_0; // // create an LPX (auto) socket // AutoSocket autoSock = CreateLpxConnection(&remoteAddress, &localAddress); // // autoSock will close the handle when it goes out of scope // if (INVALID_SOCKET == (SOCKET) autoSock) { // // TODO: EVENTLOG NDAS_DEVICE_ERROR_LPX_SOCKET_FAILED // DBGPRT_ERR_EX(_FT("Error Create Connection: ")); SetLastDeviceError(NDAS_DEVICE_ERROR_LPX_SOCKET_FAILED); return FALSE; } // // Discover // lspath.connsock = autoSock; INT iResult = Discovery(&lspath); if (0 != iResult) { // // TODO: EVENTLOG NDAS_DEVICE_ERROR_DISCOVER_FAILED // DBGPRT_ERR_EX(_FT("Discovery failed! - returned (%d) : "), iResult); SetLastDeviceError(NDAS_DEVICE_ERROR_DISCOVER_FAILED); return FALSE; } // // If discovering succeeded, set pController's // LANSCSI path to discovered LANSCSI path // m_hwInfo.nMaxRequestBlocks = lspath.iMaxBlocks; m_hwInfo.nSlots = lspath.iNumberofSlot; m_hwInfo.nTargets = lspath.iNRTargets; m_hwInfo.nMaxTargets = lspath.iMaxTargets; m_hwInfo.nMaxLUs = lspath.iMaxLUs; ::CopyMemory(&m_localLpxAddress, &localAddress, sizeof(LPX_ADDRESS)); ::CopyMemory(&m_remoteLpxAddress, &remoteAddress, sizeof(LPX_ADDRESS)); // // actual hardware type and version is filled in lspath // m_hwInfo.ucType = lspath.HWType; m_hwInfo.ucVersion = lspath.HWVersion; // // at discovery only lspath.PerTarget[i].NORWHost and NOROHost are valid. // for (DWORD i = 0; i < MAX_NDAS_UNITDEVICE_COUNT; i++) { m_fUnitDevicePresent[i] = lspath.PerTarget[i].bPresent; if (NULL != m_pUnitDevices[i]) { m_pUnitDevices[i]->SetHostUsageCount( lspath.PerTarget[i].NRROHost, lspath.PerTarget[i].NRRWHost); } } return TRUE; }
BOOL NDAS_GetStatus(UNIT_DISK_LOCATION *pUnitDisk, PNDAS_STATUS pStatus) { BOOL bReturn = FALSE; IDE_COMMAND_IO cmd[2]; LONG lResult; HKEY hKeyNetDisks; HKEY hKey; UINT i; CHAR achKey[MAX_KEY_LENGTH]; // buffer for subkey name DWORD cbName; // size of name string FILETIME ftLastWriteTime; // last write time CHAR szAddress[MAX_VALUE_NAME], szAddress2[18]; UCHAR szSerial[MAX_VALUE_NAME]; DWORD dwType; DWORD dwSize; LPX_ADDRESS address; LANSCSI_PATH path; DISK_INFORMATION_BLOCK *pDiskInfoV1; DISK_INFORMATION_BLOCK_V2 *pDiskInfoV2; DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : %02X:%02X:%02X:%02X:%02X:%02X\n", (int)pUnitDisk->MACAddr[0], (int)pUnitDisk->MACAddr[1], (int)pUnitDisk->MACAddr[2], (int)pUnitDisk->MACAddr[3], (int)pUnitDisk->MACAddr[4], (int)pUnitDisk->MACAddr[5] )); ZeroMemory(&path, sizeof(LANSCSI_PATH)); CopyMemory(address.Node, pUnitDisk->MACAddr, 6); if(NULL == pStatus) goto out; ZeroMemory(pStatus, sizeof(NDAS_STATUS)); // Registry check start. // AING_TO_DO : use NDAS registry functions lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, KEY_NAME_NETDISKS, 0, KEY_READ, &hKeyNetDisks ); if(ERROR_SUCCESS != lResult) goto out; sprintf(szAddress2, "%02x:%02x:%02x:%02x:%02x:%02x", pUnitDisk->MACAddr[0], pUnitDisk->MACAddr[1], pUnitDisk->MACAddr[2], pUnitDisk->MACAddr[3], pUnitDisk->MACAddr[4], pUnitDisk->MACAddr[5]); i = 0; while(1) { cbName = MAX_KEY_LENGTH; lResult = RegEnumKeyEx( hKeyNetDisks, i++, achKey, &cbName, NULL, NULL, NULL, &ftLastWriteTime); if(ERROR_SUCCESS != lResult) goto out; lResult = RegOpenKeyEx( hKeyNetDisks, achKey, 0, KEY_READ, &hKey ); if(ERROR_SUCCESS != lResult) goto out; dwSize = MAX_VALUE_NAME; lResult = RegQueryValueEx( hKey, "Address", 0, &dwType, szAddress, &dwSize); if(ERROR_SUCCESS != lResult) continue; if(stricmp(szAddress, szAddress2)) continue; pStatus->IsRegistered = 1; dwSize = MAX_VALUE_NAME; lResult = RegQueryValueEx( hKey, "SerialKey", 0, &dwType, szSerial, &dwSize); DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : lResult = %d szSerial = %x %x %x %x %x %x %x %x %x, %d\n", lResult, (int)szSerial[0], (int)szSerial[1], (int)szSerial[2], (int)szSerial[3], (int)szSerial[4], (int)szSerial[5], (int)szSerial[6], (int)szSerial[7], (int)szSerial[8], (szSerial[8] == 0xff) )); if(ERROR_SUCCESS == lResult && szSerial[8] == 0xff) { pStatus->IsRegisteredWritable = 1; } break; } // Registry check end. // Connect if(!MakeConnection(&address, &path) || (unsigned int)NULL == path.connsock) { DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : MakeConnection Failed\n")); goto out; } pStatus->IsAlive = 1; // Login // if we don't write, login read only path.iUserID = (pUnitDisk->SlotNumber +1); path.iCommandTag = 0; path.HPID = 0; path.iHeaderEncryptAlgo = 0; path.iDataEncryptAlgo = 0; NDAS_SetPassword(address.Node, &path.iPassword); path.iSessionPhase = LOGOUT_PHASE; if(Login(&path, LOGIN_TYPE_NORMAL)) { DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : Login Failed\n")); goto out; } if(GetDiskInfo(&path, pUnitDisk->SlotNumber)) { DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : GetDiskInfo Failed\n")); goto out; } if(Logout(&path)) { DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : Logout Failed\n")); goto out; } if(0 != Discovery(&path)) { DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : Discovery Failed\n")); goto out; } closesocket(path.connsock); pStatus->IsDiscovered = 1; pStatus->HWVersion = path.HWVersion; pStatus->HWProtoVersion = path.HWProtoVersion; pStatus->NrUserReadWrite = path.PerTarget[pUnitDisk->SlotNumber].NRRWHost; pStatus->NrUserReadOnly = path.PerTarget[pUnitDisk->SlotNumber].NRROHost; if(MEDIA_TYPE_BLOCK_DEVICE != path.PerTarget[pUnitDisk->SlotNumber].MediaType) { switch(path.PerTarget[pUnitDisk->SlotNumber].MediaType) { case MEDIA_TYPE_CDROM_DEVICE: pStatus->DiskType = DISK_TYPE_DVD; pStatus->IsSupported = 1; break; case MEDIA_TYPE_OPMEM_DEVICE: pStatus->DiskType = DISK_TYPE_MO; pStatus->IsSupported = 1; break; default: pStatus->IsSupported = 0; } DebugPrint(1, ("[NDASOpLib] NDAS_GetStatus : Packet type %d\n", path.PerTarget[pUnitDisk->SlotNumber].MediaType)); bReturn = TRUE; goto out; } cmd[0].command = WIN_READ; cmd[0].iSector = -1; pDiskInfoV1 = (PDISK_INFORMATION_BLOCK)cmd[0].data; cmd[1].command = WIN_READ; cmd[1].iSector = -2; pDiskInfoV2 = (PDISK_INFORMATION_BLOCK_V2)cmd[1].data; NDAS_IdeIO(pUnitDisk, 2, cmd, NULL); if(DISK_INFORMATION_SIGNATURE_V2 == pDiskInfoV2->Signature) { pStatus->MajorVersion = pDiskInfoV2->MajorVersion; pStatus->MinorVersion = pDiskInfoV2->MinorVersion; if(IS_NDAS_DIB_V2_VERSION_HIGH(*pDiskInfoV2)) goto out; pStatus->IsSupported = 1; pStatus->DiskType = (1 == pDiskInfoV2->nDiskCount) ? DISK_TYPE_NORMAL : (NMT_RAID1 == pDiskInfoV2->iMediaType) ? DISK_TYPE_BIND_RAID1 : (NMT_VDVD == pDiskInfoV2->iMediaType) ? DISK_TYPE_VDVD : DISK_TYPE_AGGREGATION; } else if(DISK_INFORMATION_SIGNATURE == pDiskInfoV1->Signature) { pStatus->MajorVersion = pDiskInfoV1->MajorVersion; pStatus->MinorVersion = pDiskInfoV1->MinorVersion; if(IS_WRONG_VERSION(*pDiskInfoV1)) goto out; pStatus->IsSupported = 1; pStatus->DiskType = (UNITDISK_TYPE_SINGLE == pDiskInfoV1->DiskType) ? DISK_TYPE_NORMAL : (UNITDISK_TYPE_AGGREGATION_FIRST == pDiskInfoV1->DiskType) ? DISK_TYPE_AGGREGATION : (UNITDISK_TYPE_AGGREGATION_SECOND == pDiskInfoV1->DiskType) ? DISK_TYPE_AGGREGATION : (UNITDISK_TYPE_AGGREGATION_THIRD == pDiskInfoV1->DiskType) ? DISK_TYPE_AGGREGATION : (UNITDISK_TYPE_AGGREGATION_FOURTH == pDiskInfoV1->DiskType) ? DISK_TYPE_AGGREGATION : (UNITDISK_TYPE_MIRROR_MASTER == pDiskInfoV1->DiskType) ? DISK_TYPE_BIND_RAID1 : (UNITDISK_TYPE_MIRROR_SLAVE == pDiskInfoV1->DiskType) ? DISK_TYPE_BIND_RAID1 : (UNITDISK_TYPE_VDVD == pDiskInfoV1->DiskType) ? DISK_TYPE_VDVD : 0; } else { pStatus->MajorVersion = 0; pStatus->MinorVersion = 0; pStatus->DiskType = DISK_TYPE_NORMAL; pStatus->IsSupported = 1; } bReturn = TRUE; out: if(path.connsock) closesocket(path.connsock); return bReturn; }
bool nRF5xCharacteristicDescriptorDiscoverer::Discovery::isEmpty() const { return *this == Discovery(); }