1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <android-base/logging.h> 18 #include <utils/SystemClock.h> 19 20 #include "hidl_struct_util.h" 21 22 namespace android { 23 namespace hardware { 24 namespace wifi { 25 namespace V1_1 { 26 namespace implementation { 27 namespace hidl_struct_util { 28 29 hidl_string safeConvertChar(const char* str, size_t max_len) { 30 const char* c = str; 31 size_t size = 0; 32 while (*c && (unsigned char)*c < 128 && size < max_len) { 33 ++size; 34 ++c; 35 } 36 return hidl_string(str, size); 37 } 38 39 IWifiChip::ChipCapabilityMask convertLegacyLoggerFeatureToHidlChipCapability( 40 uint32_t feature) { 41 using HidlChipCaps = IWifiChip::ChipCapabilityMask; 42 switch (feature) { 43 case legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED: 44 return HidlChipCaps::DEBUG_MEMORY_FIRMWARE_DUMP; 45 case legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED: 46 return HidlChipCaps::DEBUG_MEMORY_DRIVER_DUMP; 47 case legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED: 48 return HidlChipCaps::DEBUG_RING_BUFFER_CONNECT_EVENT; 49 case legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED: 50 return HidlChipCaps::DEBUG_RING_BUFFER_POWER_EVENT; 51 case legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED: 52 return HidlChipCaps::DEBUG_RING_BUFFER_WAKELOCK_EVENT; 53 }; 54 CHECK(false) << "Unknown legacy feature: " << feature; 55 return {}; 56 } 57 58 IWifiStaIface::StaIfaceCapabilityMask 59 convertLegacyLoggerFeatureToHidlStaIfaceCapability(uint32_t feature) { 60 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask; 61 switch (feature) { 62 case legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED: 63 return HidlStaIfaceCaps::DEBUG_PACKET_FATE; 64 }; 65 CHECK(false) << "Unknown legacy feature: " << feature; 66 return {}; 67 } 68 69 V1_1::IWifiChip::ChipCapabilityMask convertLegacyFeatureToHidlChipCapability( 70 uint32_t feature) { 71 using HidlChipCaps = V1_1::IWifiChip::ChipCapabilityMask; 72 switch (feature) { 73 case WIFI_FEATURE_SET_TX_POWER_LIMIT: 74 return HidlChipCaps::SET_TX_POWER_LIMIT; 75 case WIFI_FEATURE_D2D_RTT: 76 return HidlChipCaps::D2D_RTT; 77 case WIFI_FEATURE_D2AP_RTT: 78 return HidlChipCaps::D2AP_RTT; 79 }; 80 CHECK(false) << "Unknown legacy feature: " << feature; 81 return {}; 82 } 83 84 IWifiStaIface::StaIfaceCapabilityMask 85 convertLegacyFeatureToHidlStaIfaceCapability(uint32_t feature) { 86 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask; 87 switch (feature) { 88 case WIFI_FEATURE_GSCAN: 89 return HidlStaIfaceCaps::BACKGROUND_SCAN; 90 case WIFI_FEATURE_LINK_LAYER_STATS: 91 return HidlStaIfaceCaps::LINK_LAYER_STATS; 92 case WIFI_FEATURE_RSSI_MONITOR: 93 return HidlStaIfaceCaps::RSSI_MONITOR; 94 case WIFI_FEATURE_CONTROL_ROAMING: 95 return HidlStaIfaceCaps::CONTROL_ROAMING; 96 case WIFI_FEATURE_IE_WHITELIST: 97 return HidlStaIfaceCaps::PROBE_IE_WHITELIST; 98 case WIFI_FEATURE_SCAN_RAND: 99 return HidlStaIfaceCaps::SCAN_RAND; 100 case WIFI_FEATURE_INFRA_5G: 101 return HidlStaIfaceCaps::STA_5G; 102 case WIFI_FEATURE_HOTSPOT: 103 return HidlStaIfaceCaps::HOTSPOT; 104 case WIFI_FEATURE_PNO: 105 return HidlStaIfaceCaps::PNO; 106 case WIFI_FEATURE_TDLS: 107 return HidlStaIfaceCaps::TDLS; 108 case WIFI_FEATURE_TDLS_OFFCHANNEL: 109 return HidlStaIfaceCaps::TDLS_OFFCHANNEL; 110 case WIFI_FEATURE_CONFIG_NDO: 111 return HidlStaIfaceCaps::ND_OFFLOAD; 112 case WIFI_FEATURE_MKEEP_ALIVE: 113 return HidlStaIfaceCaps::KEEP_ALIVE; 114 }; 115 CHECK(false) << "Unknown legacy feature: " << feature; 116 return {}; 117 } 118 119 bool convertLegacyFeaturesToHidlChipCapabilities( 120 uint32_t legacy_feature_set, 121 uint32_t legacy_logger_feature_set, 122 uint32_t* hidl_caps) { 123 if (!hidl_caps) { 124 return false; 125 } 126 *hidl_caps = {}; 127 using HidlChipCaps = IWifiChip::ChipCapabilityMask; 128 for (const auto feature : {legacy_hal::WIFI_LOGGER_MEMORY_DUMP_SUPPORTED, 129 legacy_hal::WIFI_LOGGER_DRIVER_DUMP_SUPPORTED, 130 legacy_hal::WIFI_LOGGER_CONNECT_EVENT_SUPPORTED, 131 legacy_hal::WIFI_LOGGER_POWER_EVENT_SUPPORTED, 132 legacy_hal::WIFI_LOGGER_WAKE_LOCK_SUPPORTED}) { 133 if (feature & legacy_logger_feature_set) { 134 *hidl_caps |= convertLegacyLoggerFeatureToHidlChipCapability(feature); 135 } 136 } 137 for (const auto feature : {WIFI_FEATURE_SET_TX_POWER_LIMIT, 138 WIFI_FEATURE_D2D_RTT, 139 WIFI_FEATURE_D2AP_RTT}) { 140 if (feature & legacy_feature_set) { 141 *hidl_caps |= convertLegacyFeatureToHidlChipCapability(feature); 142 } 143 } 144 // There are no flags for these 3 in the legacy feature set. Adding them to 145 // the set because all the current devices support it. 146 *hidl_caps |= HidlChipCaps::DEBUG_RING_BUFFER_VENDOR_DATA; 147 *hidl_caps |= HidlChipCaps::DEBUG_HOST_WAKE_REASON_STATS; 148 *hidl_caps |= HidlChipCaps::DEBUG_ERROR_ALERTS; 149 return true; 150 } 151 152 WifiDebugRingBufferFlags convertLegacyDebugRingBufferFlagsToHidl( 153 uint32_t flag) { 154 switch (flag) { 155 case WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES: 156 return WifiDebugRingBufferFlags::HAS_BINARY_ENTRIES; 157 case WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES: 158 return WifiDebugRingBufferFlags::HAS_ASCII_ENTRIES; 159 }; 160 CHECK(false) << "Unknown legacy flag: " << flag; 161 return {}; 162 } 163 164 bool convertLegacyDebugRingBufferStatusToHidl( 165 const legacy_hal::wifi_ring_buffer_status& legacy_status, 166 WifiDebugRingBufferStatus* hidl_status) { 167 if (!hidl_status) { 168 return false; 169 } 170 *hidl_status = {}; 171 hidl_status->ringName = safeConvertChar(reinterpret_cast<const char*>(legacy_status.name), 172 sizeof(legacy_status.name)); 173 hidl_status->flags = 0; 174 for (const auto flag : {WIFI_RING_BUFFER_FLAG_HAS_BINARY_ENTRIES, 175 WIFI_RING_BUFFER_FLAG_HAS_ASCII_ENTRIES}) { 176 if (flag & legacy_status.flags) { 177 hidl_status->flags |= 178 static_cast<std::underlying_type<WifiDebugRingBufferFlags>::type>( 179 convertLegacyDebugRingBufferFlagsToHidl(flag)); 180 } 181 } 182 hidl_status->ringId = legacy_status.ring_id; 183 hidl_status->sizeInBytes = legacy_status.ring_buffer_byte_size; 184 // Calculate free size of the ring the buffer. We don't need to send the 185 // exact read/write pointers that were there in the legacy HAL interface. 186 if (legacy_status.written_bytes >= legacy_status.read_bytes) { 187 hidl_status->freeSizeInBytes = 188 legacy_status.ring_buffer_byte_size - 189 (legacy_status.written_bytes - legacy_status.read_bytes); 190 } else { 191 hidl_status->freeSizeInBytes = 192 legacy_status.read_bytes - legacy_status.written_bytes; 193 } 194 hidl_status->verboseLevel = legacy_status.verbose_level; 195 return true; 196 } 197 198 bool convertLegacyVectorOfDebugRingBufferStatusToHidl( 199 const std::vector<legacy_hal::wifi_ring_buffer_status>& legacy_status_vec, 200 std::vector<WifiDebugRingBufferStatus>* hidl_status_vec) { 201 if (!hidl_status_vec) { 202 return false; 203 } 204 *hidl_status_vec = {}; 205 for (const auto& legacy_status : legacy_status_vec) { 206 WifiDebugRingBufferStatus hidl_status; 207 if (!convertLegacyDebugRingBufferStatusToHidl(legacy_status, 208 &hidl_status)) { 209 return false; 210 } 211 hidl_status_vec->push_back(hidl_status); 212 } 213 return true; 214 } 215 216 bool convertLegacyWakeReasonStatsToHidl( 217 const legacy_hal::WakeReasonStats& legacy_stats, 218 WifiDebugHostWakeReasonStats* hidl_stats) { 219 if (!hidl_stats) { 220 return false; 221 } 222 *hidl_stats = {}; 223 hidl_stats->totalCmdEventWakeCnt = 224 legacy_stats.wake_reason_cnt.total_cmd_event_wake; 225 hidl_stats->cmdEventWakeCntPerType = legacy_stats.cmd_event_wake_cnt; 226 hidl_stats->totalDriverFwLocalWakeCnt = 227 legacy_stats.wake_reason_cnt.total_driver_fw_local_wake; 228 hidl_stats->driverFwLocalWakeCntPerType = 229 legacy_stats.driver_fw_local_wake_cnt; 230 hidl_stats->totalRxPacketWakeCnt = 231 legacy_stats.wake_reason_cnt.total_rx_data_wake; 232 hidl_stats->rxPktWakeDetails.rxUnicastCnt = 233 legacy_stats.wake_reason_cnt.rx_wake_details.rx_unicast_cnt; 234 hidl_stats->rxPktWakeDetails.rxMulticastCnt = 235 legacy_stats.wake_reason_cnt.rx_wake_details.rx_multicast_cnt; 236 hidl_stats->rxPktWakeDetails.rxBroadcastCnt = 237 legacy_stats.wake_reason_cnt.rx_wake_details.rx_broadcast_cnt; 238 hidl_stats->rxMulticastPkWakeDetails.ipv4RxMulticastAddrCnt = 239 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info 240 .ipv4_rx_multicast_addr_cnt; 241 hidl_stats->rxMulticastPkWakeDetails.ipv6RxMulticastAddrCnt = 242 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info 243 .ipv6_rx_multicast_addr_cnt; 244 hidl_stats->rxMulticastPkWakeDetails.otherRxMulticastAddrCnt = 245 legacy_stats.wake_reason_cnt.rx_multicast_wake_pkt_info 246 .other_rx_multicast_addr_cnt; 247 hidl_stats->rxIcmpPkWakeDetails.icmpPkt = 248 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp_pkt; 249 hidl_stats->rxIcmpPkWakeDetails.icmp6Pkt = 250 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_pkt; 251 hidl_stats->rxIcmpPkWakeDetails.icmp6Ra = 252 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ra; 253 hidl_stats->rxIcmpPkWakeDetails.icmp6Na = 254 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_na; 255 hidl_stats->rxIcmpPkWakeDetails.icmp6Ns = 256 legacy_stats.wake_reason_cnt.rx_wake_pkt_classification_info.icmp6_ns; 257 return true; 258 } 259 260 legacy_hal::wifi_power_scenario convertHidlTxPowerScenarioToLegacy( 261 V1_1::IWifiChip::TxPowerScenario hidl_scenario) { 262 switch (hidl_scenario) { 263 case V1_1::IWifiChip::TxPowerScenario::VOICE_CALL: 264 return legacy_hal::WIFI_POWER_SCENARIO_VOICE_CALL; 265 }; 266 CHECK(false); 267 } 268 269 bool convertLegacyFeaturesToHidlStaCapabilities( 270 uint32_t legacy_feature_set, 271 uint32_t legacy_logger_feature_set, 272 uint32_t* hidl_caps) { 273 if (!hidl_caps) { 274 return false; 275 } 276 *hidl_caps = {}; 277 using HidlStaIfaceCaps = IWifiStaIface::StaIfaceCapabilityMask; 278 for (const auto feature : {legacy_hal::WIFI_LOGGER_PACKET_FATE_SUPPORTED}) { 279 if (feature & legacy_logger_feature_set) { 280 *hidl_caps |= convertLegacyLoggerFeatureToHidlStaIfaceCapability(feature); 281 } 282 } 283 for (const auto feature : {WIFI_FEATURE_GSCAN, 284 WIFI_FEATURE_LINK_LAYER_STATS, 285 WIFI_FEATURE_RSSI_MONITOR, 286 WIFI_FEATURE_CONTROL_ROAMING, 287 WIFI_FEATURE_IE_WHITELIST, 288 WIFI_FEATURE_SCAN_RAND, 289 WIFI_FEATURE_INFRA_5G, 290 WIFI_FEATURE_HOTSPOT, 291 WIFI_FEATURE_PNO, 292 WIFI_FEATURE_TDLS, 293 WIFI_FEATURE_TDLS_OFFCHANNEL, 294 WIFI_FEATURE_CONFIG_NDO, 295 WIFI_FEATURE_MKEEP_ALIVE}) { 296 if (feature & legacy_feature_set) { 297 *hidl_caps |= convertLegacyFeatureToHidlStaIfaceCapability(feature); 298 } 299 } 300 // There is no flag for this one in the legacy feature set. Adding it to the 301 // set because all the current devices support it. 302 *hidl_caps |= HidlStaIfaceCaps::APF; 303 return true; 304 } 305 306 bool convertLegacyApfCapabilitiesToHidl( 307 const legacy_hal::PacketFilterCapabilities& legacy_caps, 308 StaApfPacketFilterCapabilities* hidl_caps) { 309 if (!hidl_caps) { 310 return false; 311 } 312 *hidl_caps = {}; 313 hidl_caps->version = legacy_caps.version; 314 hidl_caps->maxLength = legacy_caps.max_len; 315 return true; 316 } 317 318 uint8_t convertHidlGscanReportEventFlagToLegacy( 319 StaBackgroundScanBucketEventReportSchemeMask hidl_flag) { 320 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask; 321 switch (hidl_flag) { 322 case HidlFlag::EACH_SCAN: 323 return REPORT_EVENTS_EACH_SCAN; 324 case HidlFlag::FULL_RESULTS: 325 return REPORT_EVENTS_FULL_RESULTS; 326 case HidlFlag::NO_BATCH: 327 return REPORT_EVENTS_NO_BATCH; 328 }; 329 CHECK(false); 330 } 331 332 StaScanDataFlagMask convertLegacyGscanDataFlagToHidl(uint8_t legacy_flag) { 333 switch (legacy_flag) { 334 case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED: 335 return StaScanDataFlagMask::INTERRUPTED; 336 }; 337 CHECK(false) << "Unknown legacy flag: " << legacy_flag; 338 // To silence the compiler warning about reaching the end of non-void 339 // function. 340 return {}; 341 } 342 343 bool convertLegacyGscanCapabilitiesToHidl( 344 const legacy_hal::wifi_gscan_capabilities& legacy_caps, 345 StaBackgroundScanCapabilities* hidl_caps) { 346 if (!hidl_caps) { 347 return false; 348 } 349 *hidl_caps = {}; 350 hidl_caps->maxCacheSize = legacy_caps.max_scan_cache_size; 351 hidl_caps->maxBuckets = legacy_caps.max_scan_buckets; 352 hidl_caps->maxApCachePerScan = legacy_caps.max_ap_cache_per_scan; 353 hidl_caps->maxReportingThreshold = legacy_caps.max_scan_reporting_threshold; 354 return true; 355 } 356 357 legacy_hal::wifi_band convertHidlWifiBandToLegacy(WifiBand band) { 358 switch (band) { 359 case WifiBand::BAND_UNSPECIFIED: 360 return legacy_hal::WIFI_BAND_UNSPECIFIED; 361 case WifiBand::BAND_24GHZ: 362 return legacy_hal::WIFI_BAND_BG; 363 case WifiBand::BAND_5GHZ: 364 return legacy_hal::WIFI_BAND_A; 365 case WifiBand::BAND_5GHZ_DFS: 366 return legacy_hal::WIFI_BAND_A_DFS; 367 case WifiBand::BAND_5GHZ_WITH_DFS: 368 return legacy_hal::WIFI_BAND_A_WITH_DFS; 369 case WifiBand::BAND_24GHZ_5GHZ: 370 return legacy_hal::WIFI_BAND_ABG; 371 case WifiBand::BAND_24GHZ_5GHZ_WITH_DFS: 372 return legacy_hal::WIFI_BAND_ABG_WITH_DFS; 373 }; 374 CHECK(false); 375 } 376 377 bool convertHidlGscanParamsToLegacy( 378 const StaBackgroundScanParameters& hidl_scan_params, 379 legacy_hal::wifi_scan_cmd_params* legacy_scan_params) { 380 if (!legacy_scan_params) { 381 return false; 382 } 383 *legacy_scan_params = {}; 384 legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs; 385 legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan; 386 legacy_scan_params->report_threshold_percent = 387 hidl_scan_params.reportThresholdPercent; 388 legacy_scan_params->report_threshold_num_scans = 389 hidl_scan_params.reportThresholdNumScans; 390 if (hidl_scan_params.buckets.size() > MAX_BUCKETS) { 391 return false; 392 } 393 legacy_scan_params->num_buckets = hidl_scan_params.buckets.size(); 394 for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size(); 395 bucket_idx++) { 396 const StaBackgroundScanBucketParameters& hidl_bucket_spec = 397 hidl_scan_params.buckets[bucket_idx]; 398 legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec = 399 legacy_scan_params->buckets[bucket_idx]; 400 if (hidl_bucket_spec.bucketIdx >= MAX_BUCKETS) { 401 return false; 402 } 403 legacy_bucket_spec.bucket = hidl_bucket_spec.bucketIdx; 404 legacy_bucket_spec.band = 405 convertHidlWifiBandToLegacy(hidl_bucket_spec.band); 406 legacy_bucket_spec.period = hidl_bucket_spec.periodInMs; 407 legacy_bucket_spec.max_period = hidl_bucket_spec.exponentialMaxPeriodInMs; 408 legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase; 409 legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount; 410 legacy_bucket_spec.report_events = 0; 411 using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask; 412 for (const auto flag : 413 {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS, HidlFlag::NO_BATCH}) { 414 if (hidl_bucket_spec.eventReportScheme & 415 static_cast<std::underlying_type<HidlFlag>::type>(flag)) { 416 legacy_bucket_spec.report_events |= 417 convertHidlGscanReportEventFlagToLegacy(flag); 418 } 419 } 420 if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) { 421 return false; 422 } 423 legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size(); 424 for (uint32_t freq_idx = 0; freq_idx < hidl_bucket_spec.frequencies.size(); 425 freq_idx++) { 426 legacy_bucket_spec.channels[freq_idx].channel = 427 hidl_bucket_spec.frequencies[freq_idx]; 428 } 429 } 430 return true; 431 } 432 433 bool convertLegacyIeToHidl( 434 const legacy_hal::wifi_information_element& legacy_ie, 435 WifiInformationElement* hidl_ie) { 436 if (!hidl_ie) { 437 return false; 438 } 439 *hidl_ie = {}; 440 hidl_ie->id = legacy_ie.id; 441 hidl_ie->data = 442 std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len); 443 return true; 444 } 445 446 bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob, 447 uint32_t ie_blob_len, 448 std::vector<WifiInformationElement>* hidl_ies) { 449 if (!ie_blob || !hidl_ies) { 450 return false; 451 } 452 *hidl_ies = {}; 453 const uint8_t* ies_begin = ie_blob; 454 const uint8_t* ies_end = ie_blob + ie_blob_len; 455 const uint8_t* next_ie = ies_begin; 456 using wifi_ie = legacy_hal::wifi_information_element; 457 constexpr size_t kIeHeaderLen = sizeof(wifi_ie); 458 // Each IE should atleast have the header (i.e |id| & |len| fields). 459 while (next_ie + kIeHeaderLen <= ies_end) { 460 const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie)); 461 uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len; 462 if (next_ie + curr_ie_len > ies_end) { 463 LOG(ERROR) << "Error parsing IE blob. Next IE: " << (void *)next_ie 464 << ", Curr IE len: " << curr_ie_len << ", IEs End: " << (void *)ies_end; 465 break; 466 } 467 WifiInformationElement hidl_ie; 468 if (!convertLegacyIeToHidl(legacy_ie, &hidl_ie)) { 469 LOG(ERROR) << "Error converting IE. Id: " << legacy_ie.id 470 << ", len: " << legacy_ie.len; 471 break; 472 } 473 hidl_ies->push_back(std::move(hidl_ie)); 474 next_ie += curr_ie_len; 475 } 476 // Check if the blob has been fully consumed. 477 if (next_ie != ies_end) { 478 LOG(ERROR) << "Failed to fully parse IE blob. Next IE: " << (void *)next_ie 479 << ", IEs End: " << (void *)ies_end; 480 } 481 return true; 482 } 483 484 bool convertLegacyGscanResultToHidl( 485 const legacy_hal::wifi_scan_result& legacy_scan_result, 486 bool has_ie_data, 487 StaScanResult* hidl_scan_result) { 488 if (!hidl_scan_result) { 489 return false; 490 } 491 *hidl_scan_result = {}; 492 hidl_scan_result->timeStampInUs = legacy_scan_result.ts; 493 hidl_scan_result->ssid = std::vector<uint8_t>( 494 legacy_scan_result.ssid, 495 legacy_scan_result.ssid + strnlen(legacy_scan_result.ssid, 496 sizeof(legacy_scan_result.ssid) - 1)); 497 memcpy(hidl_scan_result->bssid.data(), 498 legacy_scan_result.bssid, 499 hidl_scan_result->bssid.size()); 500 hidl_scan_result->frequency = legacy_scan_result.channel; 501 hidl_scan_result->rssi = legacy_scan_result.rssi; 502 hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period; 503 hidl_scan_result->capability = legacy_scan_result.capability; 504 if (has_ie_data) { 505 std::vector<WifiInformationElement> ies; 506 if (!convertLegacyIeBlobToHidl( 507 reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data), 508 legacy_scan_result.ie_length, 509 &ies)) { 510 return false; 511 } 512 hidl_scan_result->informationElements = std::move(ies); 513 } 514 return true; 515 } 516 517 bool convertLegacyCachedGscanResultsToHidl( 518 const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result, 519 StaScanData* hidl_scan_data) { 520 if (!hidl_scan_data) { 521 return false; 522 } 523 *hidl_scan_data = {}; 524 hidl_scan_data->flags = 0; 525 for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) { 526 if (legacy_cached_scan_result.flags & flag) { 527 hidl_scan_data->flags |= 528 static_cast<std::underlying_type<StaScanDataFlagMask>::type>( 529 convertLegacyGscanDataFlagToHidl(flag)); 530 } 531 } 532 hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned; 533 534 CHECK(legacy_cached_scan_result.num_results >= 0 && 535 legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN); 536 std::vector<StaScanResult> hidl_scan_results; 537 for (int32_t result_idx = 0; 538 result_idx < legacy_cached_scan_result.num_results; 539 result_idx++) { 540 StaScanResult hidl_scan_result; 541 if (!convertLegacyGscanResultToHidl( 542 legacy_cached_scan_result.results[result_idx], 543 false, 544 &hidl_scan_result)) { 545 return false; 546 } 547 hidl_scan_results.push_back(hidl_scan_result); 548 } 549 hidl_scan_data->results = std::move(hidl_scan_results); 550 return true; 551 } 552 553 bool convertLegacyVectorOfCachedGscanResultsToHidl( 554 const std::vector<legacy_hal::wifi_cached_scan_results>& 555 legacy_cached_scan_results, 556 std::vector<StaScanData>* hidl_scan_datas) { 557 if (!hidl_scan_datas) { 558 return false; 559 } 560 *hidl_scan_datas = {}; 561 for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) { 562 StaScanData hidl_scan_data; 563 if (!convertLegacyCachedGscanResultsToHidl(legacy_cached_scan_result, 564 &hidl_scan_data)) { 565 return false; 566 } 567 hidl_scan_datas->push_back(hidl_scan_data); 568 } 569 return true; 570 } 571 572 WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl( 573 legacy_hal::wifi_tx_packet_fate fate) { 574 switch (fate) { 575 case legacy_hal::TX_PKT_FATE_ACKED: 576 return WifiDebugTxPacketFate::ACKED; 577 case legacy_hal::TX_PKT_FATE_SENT: 578 return WifiDebugTxPacketFate::SENT; 579 case legacy_hal::TX_PKT_FATE_FW_QUEUED: 580 return WifiDebugTxPacketFate::FW_QUEUED; 581 case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID: 582 return WifiDebugTxPacketFate::FW_DROP_INVALID; 583 case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS: 584 return WifiDebugTxPacketFate::FW_DROP_NOBUFS; 585 case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER: 586 return WifiDebugTxPacketFate::FW_DROP_OTHER; 587 case legacy_hal::TX_PKT_FATE_DRV_QUEUED: 588 return WifiDebugTxPacketFate::DRV_QUEUED; 589 case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID: 590 return WifiDebugTxPacketFate::DRV_DROP_INVALID; 591 case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS: 592 return WifiDebugTxPacketFate::DRV_DROP_NOBUFS; 593 case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER: 594 return WifiDebugTxPacketFate::DRV_DROP_OTHER; 595 }; 596 CHECK(false) << "Unknown legacy fate type: " << fate; 597 } 598 599 WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl( 600 legacy_hal::wifi_rx_packet_fate fate) { 601 switch (fate) { 602 case legacy_hal::RX_PKT_FATE_SUCCESS: 603 return WifiDebugRxPacketFate::SUCCESS; 604 case legacy_hal::RX_PKT_FATE_FW_QUEUED: 605 return WifiDebugRxPacketFate::FW_QUEUED; 606 case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER: 607 return WifiDebugRxPacketFate::FW_DROP_FILTER; 608 case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID: 609 return WifiDebugRxPacketFate::FW_DROP_INVALID; 610 case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS: 611 return WifiDebugRxPacketFate::FW_DROP_NOBUFS; 612 case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER: 613 return WifiDebugRxPacketFate::FW_DROP_OTHER; 614 case legacy_hal::RX_PKT_FATE_DRV_QUEUED: 615 return WifiDebugRxPacketFate::DRV_QUEUED; 616 case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER: 617 return WifiDebugRxPacketFate::DRV_DROP_FILTER; 618 case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID: 619 return WifiDebugRxPacketFate::DRV_DROP_INVALID; 620 case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS: 621 return WifiDebugRxPacketFate::DRV_DROP_NOBUFS; 622 case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER: 623 return WifiDebugRxPacketFate::DRV_DROP_OTHER; 624 }; 625 CHECK(false) << "Unknown legacy fate type: " << fate; 626 } 627 628 WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl( 629 legacy_hal::frame_type type) { 630 switch (type) { 631 case legacy_hal::FRAME_TYPE_UNKNOWN: 632 return WifiDebugPacketFateFrameType::UNKNOWN; 633 case legacy_hal::FRAME_TYPE_ETHERNET_II: 634 return WifiDebugPacketFateFrameType::ETHERNET_II; 635 case legacy_hal::FRAME_TYPE_80211_MGMT: 636 return WifiDebugPacketFateFrameType::MGMT_80211; 637 }; 638 CHECK(false) << "Unknown legacy frame type: " << type; 639 } 640 641 bool convertLegacyDebugPacketFateFrameToHidl( 642 const legacy_hal::frame_info& legacy_frame, 643 WifiDebugPacketFateFrameInfo* hidl_frame) { 644 if (!hidl_frame) { 645 return false; 646 } 647 *hidl_frame = {}; 648 hidl_frame->frameType = 649 convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type); 650 hidl_frame->frameLen = legacy_frame.frame_len; 651 hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec; 652 hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec; 653 const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>( 654 legacy_frame.frame_content.ethernet_ii_bytes); 655 hidl_frame->frameContent = 656 std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len); 657 return true; 658 } 659 660 bool convertLegacyDebugTxPacketFateToHidl( 661 const legacy_hal::wifi_tx_report& legacy_fate, 662 WifiDebugTxPacketFateReport* hidl_fate) { 663 if (!hidl_fate) { 664 return false; 665 } 666 *hidl_fate = {}; 667 hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate); 668 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf, 669 &hidl_fate->frameInfo); 670 } 671 672 bool convertLegacyVectorOfDebugTxPacketFateToHidl( 673 const std::vector<legacy_hal::wifi_tx_report>& legacy_fates, 674 std::vector<WifiDebugTxPacketFateReport>* hidl_fates) { 675 if (!hidl_fates) { 676 return false; 677 } 678 *hidl_fates = {}; 679 for (const auto& legacy_fate : legacy_fates) { 680 WifiDebugTxPacketFateReport hidl_fate; 681 if (!convertLegacyDebugTxPacketFateToHidl(legacy_fate, &hidl_fate)) { 682 return false; 683 } 684 hidl_fates->push_back(hidl_fate); 685 } 686 return true; 687 } 688 689 bool convertLegacyDebugRxPacketFateToHidl( 690 const legacy_hal::wifi_rx_report& legacy_fate, 691 WifiDebugRxPacketFateReport* hidl_fate) { 692 if (!hidl_fate) { 693 return false; 694 } 695 *hidl_fate = {}; 696 hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate); 697 return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf, 698 &hidl_fate->frameInfo); 699 } 700 701 bool convertLegacyVectorOfDebugRxPacketFateToHidl( 702 const std::vector<legacy_hal::wifi_rx_report>& legacy_fates, 703 std::vector<WifiDebugRxPacketFateReport>* hidl_fates) { 704 if (!hidl_fates) { 705 return false; 706 } 707 *hidl_fates = {}; 708 for (const auto& legacy_fate : legacy_fates) { 709 WifiDebugRxPacketFateReport hidl_fate; 710 if (!convertLegacyDebugRxPacketFateToHidl(legacy_fate, &hidl_fate)) { 711 return false; 712 } 713 hidl_fates->push_back(hidl_fate); 714 } 715 return true; 716 } 717 718 bool convertLegacyLinkLayerStatsToHidl( 719 const legacy_hal::LinkLayerStats& legacy_stats, 720 StaLinkLayerStats* hidl_stats) { 721 if (!hidl_stats) { 722 return false; 723 } 724 *hidl_stats = {}; 725 // iface legacy_stats conversion. 726 hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx; 727 hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt; 728 hidl_stats->iface.wmeBePktStats.rxMpdu = 729 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu; 730 hidl_stats->iface.wmeBePktStats.txMpdu = 731 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu; 732 hidl_stats->iface.wmeBePktStats.lostMpdu = 733 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost; 734 hidl_stats->iface.wmeBePktStats.retries = 735 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries; 736 hidl_stats->iface.wmeBkPktStats.rxMpdu = 737 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu; 738 hidl_stats->iface.wmeBkPktStats.txMpdu = 739 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu; 740 hidl_stats->iface.wmeBkPktStats.lostMpdu = 741 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost; 742 hidl_stats->iface.wmeBkPktStats.retries = 743 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries; 744 hidl_stats->iface.wmeViPktStats.rxMpdu = 745 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu; 746 hidl_stats->iface.wmeViPktStats.txMpdu = 747 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu; 748 hidl_stats->iface.wmeViPktStats.lostMpdu = 749 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost; 750 hidl_stats->iface.wmeViPktStats.retries = 751 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries; 752 hidl_stats->iface.wmeVoPktStats.rxMpdu = 753 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu; 754 hidl_stats->iface.wmeVoPktStats.txMpdu = 755 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu; 756 hidl_stats->iface.wmeVoPktStats.lostMpdu = 757 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost; 758 hidl_stats->iface.wmeVoPktStats.retries = 759 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries; 760 // radio legacy_stats conversion. 761 std::vector<StaLinkLayerRadioStats> hidl_radios_stats; 762 for (const auto& legacy_radio_stats : legacy_stats.radios) { 763 StaLinkLayerRadioStats hidl_radio_stats; 764 hidl_radio_stats.onTimeInMs = legacy_radio_stats.stats.on_time; 765 hidl_radio_stats.txTimeInMs = legacy_radio_stats.stats.tx_time; 766 hidl_radio_stats.rxTimeInMs = legacy_radio_stats.stats.rx_time; 767 hidl_radio_stats.onTimeInMsForScan = legacy_radio_stats.stats.on_time_scan; 768 hidl_radio_stats.txTimeInMsPerLevel = legacy_radio_stats.tx_time_per_levels; 769 hidl_radios_stats.push_back(hidl_radio_stats); 770 } 771 hidl_stats->radios = hidl_radios_stats; 772 // Timestamp in the HAL wrapper here since it's not provided in the legacy 773 // HAL API. 774 hidl_stats->timeStampInMs = uptimeMillis(); 775 return true; 776 } 777 778 bool convertLegacyRoamingCapabilitiesToHidl( 779 const legacy_hal::wifi_roaming_capabilities& legacy_caps, 780 StaRoamingCapabilities* hidl_caps) { 781 if (!hidl_caps) { 782 return false; 783 } 784 *hidl_caps = {}; 785 hidl_caps->maxBlacklistSize = legacy_caps.max_blacklist_size; 786 hidl_caps->maxWhitelistSize = legacy_caps.max_whitelist_size; 787 return true; 788 } 789 790 bool convertHidlRoamingConfigToLegacy( 791 const StaRoamingConfig& hidl_config, 792 legacy_hal::wifi_roaming_config* legacy_config) { 793 if (!legacy_config) { 794 return false; 795 } 796 *legacy_config = {}; 797 if (hidl_config.bssidBlacklist.size() > MAX_BLACKLIST_BSSID || 798 hidl_config.ssidWhitelist.size() > MAX_WHITELIST_SSID) { 799 return false; 800 } 801 legacy_config->num_blacklist_bssid = hidl_config.bssidBlacklist.size(); 802 uint32_t i = 0; 803 for (const auto& bssid : hidl_config.bssidBlacklist) { 804 CHECK(bssid.size() == sizeof(legacy_hal::mac_addr)); 805 memcpy(legacy_config->blacklist_bssid[i++], bssid.data(), bssid.size()); 806 } 807 legacy_config->num_whitelist_ssid = hidl_config.ssidWhitelist.size(); 808 i = 0; 809 for (const auto& ssid : hidl_config.ssidWhitelist) { 810 CHECK(ssid.size() <= sizeof(legacy_hal::ssid_t::ssid_str)); 811 legacy_config->whitelist_ssid[i].length = ssid.size(); 812 memcpy(legacy_config->whitelist_ssid[i].ssid_str, ssid.data(), ssid.size()); 813 i++; 814 } 815 return true; 816 } 817 818 legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy( 819 StaRoamingState state) { 820 switch (state) { 821 case StaRoamingState::ENABLED: 822 return legacy_hal::ROAMING_ENABLE; 823 case StaRoamingState::DISABLED: 824 return legacy_hal::ROAMING_DISABLE; 825 }; 826 CHECK(false); 827 } 828 829 legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) { 830 switch (type) { 831 case NanMatchAlg::MATCH_ONCE: 832 return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE; 833 case NanMatchAlg::MATCH_CONTINUOUS: 834 return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS; 835 case NanMatchAlg::MATCH_NEVER: 836 return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER; 837 } 838 CHECK(false); 839 } 840 841 legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(NanPublishType type) { 842 switch (type) { 843 case NanPublishType::UNSOLICITED: 844 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED; 845 case NanPublishType::SOLICITED: 846 return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED; 847 case NanPublishType::UNSOLICITED_SOLICITED: 848 return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED; 849 } 850 CHECK(false); 851 } 852 853 legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) { 854 switch (type) { 855 case NanTxType::BROADCAST: 856 return legacy_hal::NAN_TX_TYPE_BROADCAST; 857 case NanTxType::UNICAST: 858 return legacy_hal::NAN_TX_TYPE_UNICAST; 859 } 860 CHECK(false); 861 } 862 863 legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(NanSubscribeType type) { 864 switch (type) { 865 case NanSubscribeType::PASSIVE: 866 return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE; 867 case NanSubscribeType::ACTIVE: 868 return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE; 869 } 870 CHECK(false); 871 } 872 873 legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) { 874 switch (type) { 875 case NanSrfType::BLOOM_FILTER: 876 return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER; 877 case NanSrfType::PARTIAL_MAC_ADDR: 878 return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR; 879 } 880 CHECK(false); 881 } 882 883 legacy_hal::NanDataPathChannelCfg convertHidlNanDataPathChannelCfgToLegacy( 884 NanDataPathChannelCfg type) { 885 switch (type) { 886 case NanDataPathChannelCfg::CHANNEL_NOT_REQUESTED: 887 return legacy_hal::NAN_DP_CHANNEL_NOT_REQUESTED; 888 case NanDataPathChannelCfg::REQUEST_CHANNEL_SETUP: 889 return legacy_hal::NAN_DP_REQUEST_CHANNEL_SETUP; 890 case NanDataPathChannelCfg::FORCE_CHANNEL_SETUP: 891 return legacy_hal::NAN_DP_FORCE_CHANNEL_SETUP; 892 } 893 CHECK(false); 894 } 895 896 NanStatusType convertLegacyNanStatusTypeToHidl( 897 legacy_hal::NanStatusType type) { 898 switch (type) { 899 case legacy_hal::NAN_STATUS_SUCCESS: 900 return NanStatusType::SUCCESS; 901 case legacy_hal::NAN_STATUS_INTERNAL_FAILURE: 902 return NanStatusType::INTERNAL_FAILURE; 903 case legacy_hal::NAN_STATUS_PROTOCOL_FAILURE: 904 return NanStatusType::PROTOCOL_FAILURE; 905 case legacy_hal::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID: 906 return NanStatusType::INVALID_SESSION_ID; 907 case legacy_hal::NAN_STATUS_NO_RESOURCE_AVAILABLE: 908 return NanStatusType::NO_RESOURCES_AVAILABLE; 909 case legacy_hal::NAN_STATUS_INVALID_PARAM: 910 return NanStatusType::INVALID_ARGS; 911 case legacy_hal::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID: 912 return NanStatusType::INVALID_PEER_ID; 913 case legacy_hal::NAN_STATUS_INVALID_NDP_ID: 914 return NanStatusType::INVALID_NDP_ID; 915 case legacy_hal::NAN_STATUS_NAN_NOT_ALLOWED: 916 return NanStatusType::NAN_NOT_ALLOWED; 917 case legacy_hal::NAN_STATUS_NO_OTA_ACK: 918 return NanStatusType::NO_OTA_ACK; 919 case legacy_hal::NAN_STATUS_ALREADY_ENABLED: 920 return NanStatusType::ALREADY_ENABLED; 921 case legacy_hal::NAN_STATUS_FOLLOWUP_QUEUE_FULL: 922 return NanStatusType::FOLLOWUP_TX_QUEUE_FULL; 923 case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED: 924 return NanStatusType::UNSUPPORTED_CONCURRENCY_NAN_DISABLED; 925 } 926 CHECK(false); 927 } 928 929 void convertToWifiNanStatus(legacy_hal::NanStatusType type, const char* str, size_t max_len, 930 WifiNanStatus* wifiNanStatus) { 931 wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(type); 932 wifiNanStatus->description = safeConvertChar(str, max_len); 933 } 934 935 bool convertHidlNanEnableRequestToLegacy( 936 const NanEnableRequest& hidl_request, 937 legacy_hal::NanEnableRequest* legacy_request) { 938 if (!legacy_request) { 939 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: null legacy_request"; 940 return false; 941 } 942 *legacy_request = {}; 943 944 legacy_request->config_2dot4g_support = 1; 945 legacy_request->support_2dot4g_val = hidl_request.operateInBand[ 946 (size_t) NanBandIndex::NAN_BAND_24GHZ]; 947 legacy_request->config_support_5g = 1; 948 legacy_request->support_5g_val = hidl_request.operateInBand[(size_t) NanBandIndex::NAN_BAND_5GHZ]; 949 legacy_request->config_hop_count_limit = 1; 950 legacy_request->hop_count_limit_val = hidl_request.hopCountMax; 951 legacy_request->master_pref = hidl_request.configParams.masterPref; 952 legacy_request->discovery_indication_cfg = 0; 953 legacy_request->discovery_indication_cfg |= 954 hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0; 955 legacy_request->discovery_indication_cfg |= 956 hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0; 957 legacy_request->discovery_indication_cfg |= 958 hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0; 959 legacy_request->config_sid_beacon = 1; 960 if (hidl_request.configParams.numberOfPublishServiceIdsInBeacon > 127) { 961 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: numberOfPublishServiceIdsInBeacon > 127"; 962 return false; 963 } 964 legacy_request->sid_beacon_val = 965 (hidl_request.configParams.includePublishServiceIdsInBeacon ? 0x1 : 0x0) 966 | (hidl_request.configParams.numberOfPublishServiceIdsInBeacon << 1); 967 legacy_request->config_subscribe_sid_beacon = 1; 968 if (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon > 127) { 969 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: numberOfSubscribeServiceIdsInBeacon > 127"; 970 return false; 971 } 972 legacy_request->subscribe_sid_beacon_val = 973 (hidl_request.configParams.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) 974 | (hidl_request.configParams.numberOfSubscribeServiceIdsInBeacon << 1); 975 legacy_request->config_rssi_window_size = 1; 976 legacy_request->rssi_window_size_val = hidl_request.configParams.rssiWindowSize; 977 legacy_request->config_disc_mac_addr_randomization = 1; 978 legacy_request->disc_mac_addr_rand_interval_sec = 979 hidl_request.configParams.macAddressRandomizationIntervalSec; 980 legacy_request->config_2dot4g_rssi_close = 1; 981 if (hidl_request.configParams.bandSpecificConfig.size() != 2) { 982 LOG(ERROR) << "convertHidlNanEnableRequestToLegacy: bandSpecificConfig.size() != 2"; 983 return false; 984 } 985 legacy_request->rssi_close_2dot4g_val = 986 hidl_request.configParams.bandSpecificConfig[ 987 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose; 988 legacy_request->config_2dot4g_rssi_middle = 1; 989 legacy_request->rssi_middle_2dot4g_val = 990 hidl_request.configParams.bandSpecificConfig[ 991 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle; 992 legacy_request->config_2dot4g_rssi_proximity = 1; 993 legacy_request->rssi_proximity_2dot4g_val = 994 hidl_request.configParams.bandSpecificConfig[ 995 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity; 996 legacy_request->config_scan_params = 1; 997 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] = 998 hidl_request.configParams.bandSpecificConfig[ 999 (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs; 1000 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] = 1001 hidl_request.configParams.bandSpecificConfig[ 1002 (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec; 1003 legacy_request->config_dw.config_2dot4g_dw_band = hidl_request.configParams 1004 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal; 1005 legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request.configParams 1006 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal; 1007 legacy_request->config_5g_rssi_close = 1; 1008 legacy_request->rssi_close_5g_val = 1009 hidl_request.configParams.bandSpecificConfig[ 1010 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose; 1011 legacy_request->config_5g_rssi_middle = 1; 1012 legacy_request->rssi_middle_5g_val = 1013 hidl_request.configParams.bandSpecificConfig[ 1014 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle; 1015 legacy_request->config_5g_rssi_close_proximity = 1; 1016 legacy_request->rssi_close_proximity_5g_val = 1017 hidl_request.configParams.bandSpecificConfig[ 1018 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiCloseProximity; 1019 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] = 1020 hidl_request.configParams.bandSpecificConfig[ 1021 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs; 1022 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] = 1023 hidl_request.configParams.bandSpecificConfig[ 1024 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec; 1025 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] = 1026 hidl_request.configParams.bandSpecificConfig[ 1027 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs; 1028 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] = 1029 hidl_request.configParams.bandSpecificConfig[ 1030 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec; 1031 legacy_request->config_dw.config_5g_dw_band = hidl_request.configParams 1032 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal; 1033 legacy_request->config_dw.dw_5g_interval_val = hidl_request.configParams 1034 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal; 1035 if (hidl_request.debugConfigs.validClusterIdVals) { 1036 legacy_request->cluster_low = hidl_request.debugConfigs.clusterIdBottomRangeVal; 1037 legacy_request->cluster_high = hidl_request.debugConfigs.clusterIdTopRangeVal; 1038 } else { // need 'else' since not configurable in legacy HAL 1039 legacy_request->cluster_low = 0x0000; 1040 legacy_request->cluster_high = 0xFFFF; 1041 } 1042 legacy_request->config_intf_addr = hidl_request.debugConfigs.validIntfAddrVal; 1043 memcpy(legacy_request->intf_addr_val, hidl_request.debugConfigs.intfAddrVal.data(), 6); 1044 legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal; 1045 legacy_request->oui_val = hidl_request.debugConfigs.ouiVal; 1046 legacy_request->config_random_factor_force = hidl_request.debugConfigs.validRandomFactorForceVal; 1047 legacy_request->random_factor_force_val = hidl_request.debugConfigs.randomFactorForceVal; 1048 legacy_request->config_hop_count_force = hidl_request.debugConfigs.validHopCountForceVal; 1049 legacy_request->hop_count_force_val = hidl_request.debugConfigs.hopCountForceVal; 1050 legacy_request->config_24g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal; 1051 legacy_request->channel_24g_val = 1052 hidl_request.debugConfigs.discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_24GHZ]; 1053 legacy_request->config_5g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal; 1054 legacy_request->channel_5g_val = hidl_request.debugConfigs 1055 .discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_5GHZ]; 1056 legacy_request->config_2dot4g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal; 1057 legacy_request->beacon_2dot4g_val = hidl_request.debugConfigs 1058 .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ]; 1059 legacy_request->config_5g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal; 1060 legacy_request->beacon_5g_val = hidl_request.debugConfigs 1061 .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ]; 1062 legacy_request->config_2dot4g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal; 1063 legacy_request->sdf_2dot4g_val = hidl_request.debugConfigs 1064 .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ]; 1065 legacy_request->config_5g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal; 1066 legacy_request->sdf_5g_val = hidl_request.debugConfigs 1067 .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ]; 1068 1069 return true; 1070 } 1071 1072 bool convertHidlNanPublishRequestToLegacy( 1073 const NanPublishRequest& hidl_request, 1074 legacy_hal::NanPublishRequest* legacy_request) { 1075 if (!legacy_request) { 1076 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: null legacy_request"; 1077 return false; 1078 } 1079 *legacy_request = {}; 1080 1081 legacy_request->publish_id = hidl_request.baseConfigs.sessionId; 1082 legacy_request->ttl = hidl_request.baseConfigs.ttlSec; 1083 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod; 1084 legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount; 1085 legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size(); 1086 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) { 1087 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_name_len too large"; 1088 return false; 1089 } 1090 memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(), 1091 legacy_request->service_name_len); 1092 legacy_request->publish_match_indicator = 1093 convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator); 1094 legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size(); 1095 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) { 1096 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: service_specific_info_len too large"; 1097 return false; 1098 } 1099 memcpy(legacy_request->service_specific_info, 1100 hidl_request.baseConfigs.serviceSpecificInfo.data(), 1101 legacy_request->service_specific_info_len); 1102 legacy_request->sdea_service_specific_info_len = 1103 hidl_request.baseConfigs.extendedServiceSpecificInfo.size(); 1104 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) { 1105 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: sdea_service_specific_info_len too large"; 1106 return false; 1107 } 1108 memcpy(legacy_request->sdea_service_specific_info, 1109 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(), 1110 legacy_request->sdea_service_specific_info_len); 1111 legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size(); 1112 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) { 1113 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: rx_match_filter_len too large"; 1114 return false; 1115 } 1116 memcpy(legacy_request->rx_match_filter, 1117 hidl_request.baseConfigs.rxMatchFilter.data(), 1118 legacy_request->rx_match_filter_len); 1119 legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size(); 1120 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) { 1121 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: tx_match_filter_len too large"; 1122 return false; 1123 } 1124 memcpy(legacy_request->tx_match_filter, 1125 hidl_request.baseConfigs.txMatchFilter.data(), 1126 legacy_request->tx_match_filter_len); 1127 legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold; 1128 legacy_request->recv_indication_cfg = 0; 1129 legacy_request->recv_indication_cfg |= 1130 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0; 1131 legacy_request->recv_indication_cfg |= 1132 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0; 1133 legacy_request->recv_indication_cfg |= 1134 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0; 1135 legacy_request->recv_indication_cfg |= 0x8; 1136 legacy_request->cipher_type = (unsigned int) hidl_request.baseConfigs.securityConfig.cipherType; 1137 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) { 1138 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK; 1139 legacy_request->key_info.body.pmk_info.pmk_len = 1140 hidl_request.baseConfigs.securityConfig.pmk.size(); 1141 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) { 1142 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: invalid pmk_len"; 1143 return false; 1144 } 1145 memcpy(legacy_request->key_info.body.pmk_info.pmk, 1146 hidl_request.baseConfigs.securityConfig.pmk.data(), 1147 legacy_request->key_info.body.pmk_info.pmk_len); 1148 } 1149 if (hidl_request.baseConfigs.securityConfig.securityType 1150 == NanDataPathSecurityType::PASSPHRASE) { 1151 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE; 1152 legacy_request->key_info.body.passphrase_info.passphrase_len = 1153 hidl_request.baseConfigs.securityConfig.passphrase.size(); 1154 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1155 < NAN_SECURITY_MIN_PASSPHRASE_LEN) { 1156 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: passphrase_len too small"; 1157 return false; 1158 } 1159 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1160 > NAN_SECURITY_MAX_PASSPHRASE_LEN) { 1161 LOG(ERROR) << "convertHidlNanPublishRequestToLegacy: passphrase_len too large"; 1162 return false; 1163 } 1164 memcpy(legacy_request->key_info.body.passphrase_info.passphrase, 1165 hidl_request.baseConfigs.securityConfig.passphrase.data(), 1166 legacy_request->key_info.body.passphrase_info.passphrase_len); 1167 } 1168 legacy_request->sdea_params.security_cfg = (hidl_request.baseConfigs.securityConfig.securityType 1169 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY 1170 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY; 1171 legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ? 1172 legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE; 1173 legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec; 1174 legacy_request->ranging_cfg.config_ranging_indications = 1175 hidl_request.baseConfigs.configRangingIndications; 1176 legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm; 1177 legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm; 1178 legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ? 1179 legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE; 1180 legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT; 1181 legacy_request->publish_type = convertHidlNanPublishTypeToLegacy(hidl_request.publishType); 1182 legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType); 1183 legacy_request->service_responder_policy = hidl_request.autoAcceptDataPathRequests ? 1184 legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE; 1185 1186 return true; 1187 } 1188 1189 bool convertHidlNanSubscribeRequestToLegacy( 1190 const NanSubscribeRequest& hidl_request, 1191 legacy_hal::NanSubscribeRequest* legacy_request) { 1192 if (!legacy_request) { 1193 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: legacy_request is null"; 1194 return false; 1195 } 1196 *legacy_request = {}; 1197 1198 legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId; 1199 legacy_request->ttl = hidl_request.baseConfigs.ttlSec; 1200 legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod; 1201 legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount; 1202 legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size(); 1203 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) { 1204 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_name_len too large"; 1205 return false; 1206 } 1207 memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.data(), 1208 legacy_request->service_name_len); 1209 legacy_request->subscribe_match_indicator = 1210 convertHidlNanMatchAlgToLegacy(hidl_request.baseConfigs.discoveryMatchIndicator); 1211 legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size(); 1212 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) { 1213 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: service_specific_info_len too large"; 1214 return false; 1215 } 1216 memcpy(legacy_request->service_specific_info, 1217 hidl_request.baseConfigs.serviceSpecificInfo.data(), 1218 legacy_request->service_specific_info_len); 1219 legacy_request->sdea_service_specific_info_len = 1220 hidl_request.baseConfigs.extendedServiceSpecificInfo.size(); 1221 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) { 1222 LOG(ERROR) << 1223 "convertHidlNanSubscribeRequestToLegacy: sdea_service_specific_info_len too large"; 1224 return false; 1225 } 1226 memcpy(legacy_request->sdea_service_specific_info, 1227 hidl_request.baseConfigs.extendedServiceSpecificInfo.data(), 1228 legacy_request->sdea_service_specific_info_len); 1229 legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size(); 1230 if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) { 1231 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: rx_match_filter_len too large"; 1232 return false; 1233 } 1234 memcpy(legacy_request->rx_match_filter, 1235 hidl_request.baseConfigs.rxMatchFilter.data(), 1236 legacy_request->rx_match_filter_len); 1237 legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size(); 1238 if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) { 1239 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: tx_match_filter_len too large"; 1240 return false; 1241 } 1242 memcpy(legacy_request->tx_match_filter, 1243 hidl_request.baseConfigs.txMatchFilter.data(), 1244 legacy_request->tx_match_filter_len); 1245 legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold; 1246 legacy_request->recv_indication_cfg = 0; 1247 legacy_request->recv_indication_cfg |= 1248 hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0; 1249 legacy_request->recv_indication_cfg |= 1250 hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0; 1251 legacy_request->recv_indication_cfg |= 1252 hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0; 1253 legacy_request->cipher_type = (unsigned int) hidl_request.baseConfigs.securityConfig.cipherType; 1254 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PMK) { 1255 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK; 1256 legacy_request->key_info.body.pmk_info.pmk_len = 1257 hidl_request.baseConfigs.securityConfig.pmk.size(); 1258 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) { 1259 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: invalid pmk_len"; 1260 return false; 1261 } 1262 memcpy(legacy_request->key_info.body.pmk_info.pmk, 1263 hidl_request.baseConfigs.securityConfig.pmk.data(), 1264 legacy_request->key_info.body.pmk_info.pmk_len); 1265 } 1266 if (hidl_request.baseConfigs.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) { 1267 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE; 1268 legacy_request->key_info.body.passphrase_info.passphrase_len = 1269 hidl_request.baseConfigs.securityConfig.passphrase.size(); 1270 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1271 < NAN_SECURITY_MIN_PASSPHRASE_LEN) { 1272 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: passphrase_len too small"; 1273 return false; 1274 } 1275 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1276 > NAN_SECURITY_MAX_PASSPHRASE_LEN) { 1277 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: passphrase_len too large"; 1278 return false; 1279 } 1280 memcpy(legacy_request->key_info.body.passphrase_info.passphrase, 1281 hidl_request.baseConfigs.securityConfig.passphrase.data(), 1282 legacy_request->key_info.body.passphrase_info.passphrase_len); 1283 } 1284 legacy_request->sdea_params.security_cfg = (hidl_request.baseConfigs.securityConfig.securityType 1285 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY 1286 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY; 1287 legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ? 1288 legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE; 1289 legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec; 1290 legacy_request->ranging_cfg.config_ranging_indications = 1291 hidl_request.baseConfigs.configRangingIndications; 1292 legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm; 1293 legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm; 1294 legacy_request->ranging_auto_response = hidl_request.baseConfigs.rangingRequired ? 1295 legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE; 1296 legacy_request->sdea_params.range_report = legacy_hal::NAN_DISABLE_RANGE_REPORT; 1297 legacy_request->subscribe_type = convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType); 1298 legacy_request->serviceResponseFilter = convertHidlNanSrfTypeToLegacy(hidl_request.srfType); 1299 legacy_request->serviceResponseInclude = hidl_request.srfRespondIfInAddressSet ? 1300 legacy_hal::NAN_SRF_INCLUDE_RESPOND : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND; 1301 legacy_request->useServiceResponseFilter = hidl_request.shouldUseSrf ? 1302 legacy_hal::NAN_USE_SRF : legacy_hal::NAN_DO_NOT_USE_SRF; 1303 legacy_request->ssiRequiredForMatchIndication = hidl_request.isSsiRequiredForMatch ? 1304 legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND; 1305 legacy_request->num_intf_addr_present = hidl_request.intfAddr.size(); 1306 if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) { 1307 LOG(ERROR) << "convertHidlNanSubscribeRequestToLegacy: num_intf_addr_present - too many"; 1308 return false; 1309 } 1310 for (int i = 0; i < legacy_request->num_intf_addr_present; i++) { 1311 memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(), 6); 1312 } 1313 1314 return true; 1315 } 1316 1317 bool convertHidlNanTransmitFollowupRequestToLegacy( 1318 const NanTransmitFollowupRequest& hidl_request, 1319 legacy_hal::NanTransmitFollowupRequest* legacy_request) { 1320 if (!legacy_request) { 1321 LOG(ERROR) << "convertHidlNanTransmitFollowupRequestToLegacy: legacy_request is null"; 1322 return false; 1323 } 1324 *legacy_request = {}; 1325 1326 legacy_request->publish_subscribe_id = hidl_request.discoverySessionId; 1327 legacy_request->requestor_instance_id = hidl_request.peerId; 1328 memcpy(legacy_request->addr, hidl_request.addr.data(), 6); 1329 legacy_request->priority = hidl_request.isHighPriority ? 1330 legacy_hal::NAN_TX_PRIORITY_HIGH : legacy_hal::NAN_TX_PRIORITY_NORMAL; 1331 legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow ? 1332 legacy_hal::NAN_TRANSMIT_IN_DW : legacy_hal::NAN_TRANSMIT_IN_FAW; 1333 legacy_request->service_specific_info_len = hidl_request.serviceSpecificInfo.size(); 1334 if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) { 1335 LOG(ERROR) << 1336 "convertHidlNanTransmitFollowupRequestToLegacy: service_specific_info_len too large"; 1337 return false; 1338 } 1339 memcpy(legacy_request->service_specific_info, 1340 hidl_request.serviceSpecificInfo.data(), 1341 legacy_request->service_specific_info_len); 1342 legacy_request->sdea_service_specific_info_len = hidl_request.extendedServiceSpecificInfo.size(); 1343 if (legacy_request->sdea_service_specific_info_len > NAN_MAX_SDEA_SERVICE_SPECIFIC_INFO_LEN) { 1344 LOG(ERROR) << 1345 "convertHidlNanTransmitFollowupRequestToLegacy: sdea_service_specific_info_len too large"; 1346 return false; 1347 } 1348 memcpy(legacy_request->sdea_service_specific_info, 1349 hidl_request.extendedServiceSpecificInfo.data(), 1350 legacy_request->sdea_service_specific_info_len); 1351 legacy_request->recv_indication_cfg = hidl_request.disableFollowupResultIndication ? 0x1 : 0x0; 1352 1353 return true; 1354 } 1355 1356 bool convertHidlNanConfigRequestToLegacy( 1357 const NanConfigRequest& hidl_request, 1358 legacy_hal::NanConfigRequest* legacy_request) { 1359 if (!legacy_request) { 1360 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: legacy_request is null"; 1361 return false; 1362 } 1363 *legacy_request = {}; 1364 1365 // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown defaults 1366 legacy_request->master_pref = hidl_request.masterPref; 1367 legacy_request->discovery_indication_cfg = 0; 1368 legacy_request->discovery_indication_cfg |= 1369 hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0; 1370 legacy_request->discovery_indication_cfg |= 1371 hidl_request.disableStartedClusterIndication ? 0x2 : 0x0; 1372 legacy_request->discovery_indication_cfg |= 1373 hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0; 1374 legacy_request->config_sid_beacon = 1; 1375 if (hidl_request.numberOfPublishServiceIdsInBeacon > 127) { 1376 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: numberOfPublishServiceIdsInBeacon > 127"; 1377 return false; 1378 } 1379 legacy_request->sid_beacon = (hidl_request.includePublishServiceIdsInBeacon ? 0x1 : 0x0) 1380 | (hidl_request.numberOfPublishServiceIdsInBeacon << 1); 1381 legacy_request->config_subscribe_sid_beacon = 1; 1382 if (hidl_request.numberOfSubscribeServiceIdsInBeacon > 127) { 1383 LOG(ERROR) << "convertHidlNanConfigRequestToLegacy: numberOfSubscribeServiceIdsInBeacon > 127"; 1384 return false; 1385 } 1386 legacy_request->subscribe_sid_beacon_val = 1387 (hidl_request.includeSubscribeServiceIdsInBeacon ? 0x1 : 0x0) 1388 | (hidl_request.numberOfSubscribeServiceIdsInBeacon << 1); 1389 legacy_request->config_rssi_window_size = 1; 1390 legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize; 1391 legacy_request->config_disc_mac_addr_randomization = 1; 1392 legacy_request->disc_mac_addr_rand_interval_sec = 1393 hidl_request.macAddressRandomizationIntervalSec; 1394 /* TODO : missing 1395 legacy_request->config_2dot4g_rssi_close = 1; 1396 legacy_request->rssi_close_2dot4g_val = 1397 hidl_request.bandSpecificConfig[ 1398 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose; 1399 legacy_request->config_2dot4g_rssi_middle = 1; 1400 legacy_request->rssi_middle_2dot4g_val = 1401 hidl_request.bandSpecificConfig[ 1402 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle; 1403 legacy_request->config_2dot4g_rssi_proximity = 1; 1404 legacy_request->rssi_proximity_2dot4g_val = 1405 hidl_request.bandSpecificConfig[ 1406 (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiCloseProximity; 1407 */ 1408 legacy_request->config_scan_params = 1; 1409 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] = 1410 hidl_request.bandSpecificConfig[ 1411 (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs; 1412 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] = 1413 hidl_request.bandSpecificConfig[ 1414 (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec; 1415 legacy_request->config_dw.config_2dot4g_dw_band = hidl_request 1416 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal; 1417 legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request 1418 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal; 1419 /* TODO: missing 1420 legacy_request->config_5g_rssi_close = 1; 1421 legacy_request->rssi_close_5g_val = 1422 hidl_request.bandSpecificConfig[ 1423 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose; 1424 legacy_request->config_5g_rssi_middle = 1; 1425 legacy_request->rssi_middle_5g_val = 1426 hidl_request.bandSpecificConfig[ 1427 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle; 1428 */ 1429 legacy_request->config_5g_rssi_close_proximity = 1; 1430 legacy_request->rssi_close_proximity_5g_val = 1431 hidl_request.bandSpecificConfig[ 1432 (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiCloseProximity; 1433 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] = 1434 hidl_request.bandSpecificConfig[ 1435 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs; 1436 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] = 1437 hidl_request.bandSpecificConfig[ 1438 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec; 1439 legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] = 1440 hidl_request.bandSpecificConfig[ 1441 (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs; 1442 legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] = 1443 hidl_request.bandSpecificConfig[ 1444 (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec; 1445 legacy_request->config_dw.config_5g_dw_band = hidl_request 1446 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal; 1447 legacy_request->config_dw.dw_5g_interval_val = hidl_request 1448 .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal; 1449 1450 return true; 1451 } 1452 1453 bool convertHidlNanDataPathInitiatorRequestToLegacy( 1454 const NanInitiateDataPathRequest& hidl_request, 1455 legacy_hal::NanDataPathInitiatorRequest* legacy_request) { 1456 if (!legacy_request) { 1457 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: legacy_request is null"; 1458 return false; 1459 } 1460 *legacy_request = {}; 1461 1462 legacy_request->requestor_instance_id = hidl_request.peerId; 1463 memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6); 1464 legacy_request->channel_request_type = 1465 convertHidlNanDataPathChannelCfgToLegacy(hidl_request.channelRequestType); 1466 legacy_request->channel = hidl_request.channel; 1467 strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str()); 1468 legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType 1469 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY 1470 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY; 1471 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size(); 1472 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) { 1473 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: ndp_app_info_len too large"; 1474 return false; 1475 } 1476 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(), 1477 legacy_request->app_info.ndp_app_info_len); 1478 legacy_request->cipher_type = (unsigned int) hidl_request.securityConfig.cipherType; 1479 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) { 1480 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK; 1481 legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size(); 1482 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) { 1483 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: invalid pmk_len"; 1484 return false; 1485 } 1486 memcpy(legacy_request->key_info.body.pmk_info.pmk, 1487 hidl_request.securityConfig.pmk.data(), 1488 legacy_request->key_info.body.pmk_info.pmk_len); 1489 } 1490 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) { 1491 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE; 1492 legacy_request->key_info.body.passphrase_info.passphrase_len = 1493 hidl_request.securityConfig.passphrase.size(); 1494 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1495 < NAN_SECURITY_MIN_PASSPHRASE_LEN) { 1496 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: passphrase_len too small"; 1497 return false; 1498 } 1499 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1500 > NAN_SECURITY_MAX_PASSPHRASE_LEN) { 1501 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: passphrase_len too large"; 1502 return false; 1503 } 1504 memcpy(legacy_request->key_info.body.passphrase_info.passphrase, 1505 hidl_request.securityConfig.passphrase.data(), 1506 legacy_request->key_info.body.passphrase_info.passphrase_len); 1507 } 1508 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size(); 1509 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) { 1510 LOG(ERROR) << "convertHidlNanDataPathInitiatorRequestToLegacy: service_name_len too large"; 1511 return false; 1512 } 1513 memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(), 1514 legacy_request->service_name_len); 1515 1516 return true; 1517 } 1518 1519 bool convertHidlNanDataPathIndicationResponseToLegacy( 1520 const NanRespondToDataPathIndicationRequest& hidl_request, 1521 legacy_hal::NanDataPathIndicationResponse* legacy_request) { 1522 if (!legacy_request) { 1523 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: legacy_request is null"; 1524 return false; 1525 } 1526 *legacy_request = {}; 1527 1528 legacy_request->rsp_code = hidl_request.acceptRequest ? 1529 legacy_hal::NAN_DP_REQUEST_ACCEPT : legacy_hal::NAN_DP_REQUEST_REJECT; 1530 legacy_request->ndp_instance_id = hidl_request.ndpInstanceId; 1531 strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str()); 1532 legacy_request->ndp_cfg.security_cfg = (hidl_request.securityConfig.securityType 1533 != NanDataPathSecurityType::OPEN) ? legacy_hal::NAN_DP_CONFIG_SECURITY 1534 : legacy_hal::NAN_DP_CONFIG_NO_SECURITY; 1535 legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size(); 1536 if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) { 1537 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: ndp_app_info_len too large"; 1538 return false; 1539 } 1540 memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(), 1541 legacy_request->app_info.ndp_app_info_len); 1542 legacy_request->cipher_type = (unsigned int) hidl_request.securityConfig.cipherType; 1543 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PMK) { 1544 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK; 1545 legacy_request->key_info.body.pmk_info.pmk_len = hidl_request.securityConfig.pmk.size(); 1546 if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) { 1547 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: invalid pmk_len"; 1548 return false; 1549 } 1550 memcpy(legacy_request->key_info.body.pmk_info.pmk, 1551 hidl_request.securityConfig.pmk.data(), 1552 legacy_request->key_info.body.pmk_info.pmk_len); 1553 } 1554 if (hidl_request.securityConfig.securityType == NanDataPathSecurityType::PASSPHRASE) { 1555 legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE; 1556 legacy_request->key_info.body.passphrase_info.passphrase_len = 1557 hidl_request.securityConfig.passphrase.size(); 1558 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1559 < NAN_SECURITY_MIN_PASSPHRASE_LEN) { 1560 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: passphrase_len too small"; 1561 return false; 1562 } 1563 if (legacy_request->key_info.body.passphrase_info.passphrase_len 1564 > NAN_SECURITY_MAX_PASSPHRASE_LEN) { 1565 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: passphrase_len too large"; 1566 return false; 1567 } 1568 memcpy(legacy_request->key_info.body.passphrase_info.passphrase, 1569 hidl_request.securityConfig.passphrase.data(), 1570 legacy_request->key_info.body.passphrase_info.passphrase_len); 1571 } 1572 legacy_request->service_name_len = hidl_request.serviceNameOutOfBand.size(); 1573 if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) { 1574 LOG(ERROR) << "convertHidlNanDataPathIndicationResponseToLegacy: service_name_len too large"; 1575 return false; 1576 } 1577 memcpy(legacy_request->service_name, hidl_request.serviceNameOutOfBand.data(), 1578 legacy_request->service_name_len); 1579 1580 return true; 1581 } 1582 1583 bool convertLegacyNanResponseHeaderToHidl( 1584 const legacy_hal::NanResponseMsg& legacy_response, 1585 WifiNanStatus* wifiNanStatus) { 1586 if (!wifiNanStatus) { 1587 LOG(ERROR) << "convertLegacyNanResponseHeaderToHidl: wifiNanStatus is null"; 1588 return false; 1589 } 1590 *wifiNanStatus = {}; 1591 1592 convertToWifiNanStatus(legacy_response.status, legacy_response.nan_error, 1593 sizeof(legacy_response.nan_error), wifiNanStatus); 1594 return true; 1595 } 1596 1597 bool convertLegacyNanCapabilitiesResponseToHidl( 1598 const legacy_hal::NanCapabilities& legacy_response, 1599 NanCapabilities* hidl_response) { 1600 if (!hidl_response) { 1601 LOG(ERROR) << "convertLegacyNanCapabilitiesResponseToHidl: hidl_response is null"; 1602 return false; 1603 } 1604 *hidl_response = {}; 1605 1606 hidl_response->maxConcurrentClusters = legacy_response.max_concurrent_nan_clusters; 1607 hidl_response->maxPublishes = legacy_response.max_publishes; 1608 hidl_response->maxSubscribes = legacy_response.max_subscribes; 1609 hidl_response->maxServiceNameLen = legacy_response.max_service_name_len; 1610 hidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len; 1611 hidl_response->maxTotalMatchFilterLen = legacy_response.max_total_match_filter_len; 1612 hidl_response->maxServiceSpecificInfoLen = legacy_response.max_service_specific_info_len; 1613 hidl_response->maxExtendedServiceSpecificInfoLen = 1614 legacy_response.max_sdea_service_specific_info_len; 1615 hidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces; 1616 hidl_response->maxNdpSessions = legacy_response.max_ndp_sessions; 1617 hidl_response->maxAppInfoLen = legacy_response.max_app_info_len; 1618 hidl_response->maxQueuedTransmitFollowupMsgs = legacy_response.max_queued_transmit_followup_msgs; 1619 hidl_response->maxSubscribeInterfaceAddresses = legacy_response.max_subscribe_address; 1620 hidl_response->supportedCipherSuites = legacy_response.cipher_suites_supported; 1621 1622 return true; 1623 } 1624 1625 bool convertLegacyNanMatchIndToHidl( 1626 const legacy_hal::NanMatchInd& legacy_ind, 1627 NanMatchInd* hidl_ind) { 1628 if (!hidl_ind) { 1629 LOG(ERROR) << "convertLegacyNanMatchIndToHidl: hidl_ind is null"; 1630 return false; 1631 } 1632 *hidl_ind = {}; 1633 1634 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id; 1635 hidl_ind->peerId = legacy_ind.requestor_instance_id; 1636 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr); 1637 hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(legacy_ind.service_specific_info, 1638 legacy_ind.service_specific_info + legacy_ind.service_specific_info_len); 1639 hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>( 1640 legacy_ind.sdea_service_specific_info, 1641 legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len); 1642 hidl_ind->matchFilter = std::vector<uint8_t>(legacy_ind.sdf_match_filter, 1643 legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len); 1644 hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1; 1645 hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1; 1646 hidl_ind->rssiValue = legacy_ind.rssi_value; 1647 hidl_ind->peerCipherType = (NanCipherSuiteType) legacy_ind.peer_cipher_type; 1648 hidl_ind->peerRequiresSecurityEnabledInNdp = 1649 legacy_ind.peer_sdea_params.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY; 1650 hidl_ind->peerRequiresRanging = 1651 legacy_ind.peer_sdea_params.ranging_state == legacy_hal::NAN_RANGING_ENABLE; 1652 hidl_ind->rangingMeasurementInCm = legacy_ind.range_info.range_measurement_cm; 1653 hidl_ind->rangingIndicationType = legacy_ind.range_info.ranging_event_type; 1654 1655 return true; 1656 } 1657 1658 bool convertLegacyNanFollowupIndToHidl( 1659 const legacy_hal::NanFollowupInd& legacy_ind, 1660 NanFollowupReceivedInd* hidl_ind) { 1661 if (!hidl_ind) { 1662 LOG(ERROR) << "convertLegacyNanFollowupIndToHidl: hidl_ind is null"; 1663 return false; 1664 } 1665 *hidl_ind = {}; 1666 1667 hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id; 1668 hidl_ind->peerId = legacy_ind.requestor_instance_id; 1669 hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr); 1670 hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1; 1671 hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(legacy_ind.service_specific_info, 1672 legacy_ind.service_specific_info + legacy_ind.service_specific_info_len); 1673 hidl_ind->extendedServiceSpecificInfo = std::vector<uint8_t>( 1674 legacy_ind.sdea_service_specific_info, 1675 legacy_ind.sdea_service_specific_info + legacy_ind.sdea_service_specific_info_len); 1676 1677 return true; 1678 } 1679 1680 bool convertLegacyNanDataPathRequestIndToHidl( 1681 const legacy_hal::NanDataPathRequestInd& legacy_ind, 1682 NanDataPathRequestInd* hidl_ind) { 1683 if (!hidl_ind) { 1684 LOG(ERROR) << "convertLegacyNanDataPathRequestIndToHidl: hidl_ind is null"; 1685 return false; 1686 } 1687 *hidl_ind = {}; 1688 1689 hidl_ind->discoverySessionId = legacy_ind.service_instance_id; 1690 hidl_ind->peerDiscMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr); 1691 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id; 1692 hidl_ind->securityRequired = 1693 legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY; 1694 hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info, 1695 legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len); 1696 1697 return true; 1698 } 1699 1700 bool convertLegacyNanDataPathConfirmIndToHidl( 1701 const legacy_hal::NanDataPathConfirmInd& legacy_ind, 1702 NanDataPathConfirmInd* hidl_ind) { 1703 if (!hidl_ind) { 1704 LOG(ERROR) << "convertLegacyNanDataPathConfirmIndToHidl: hidl_ind is null"; 1705 return false; 1706 } 1707 *hidl_ind = {}; 1708 1709 hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id; 1710 hidl_ind->dataPathSetupSuccess = legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT; 1711 hidl_ind->peerNdiMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr); 1712 hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info, 1713 legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len); 1714 hidl_ind->status.status = convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code); 1715 hidl_ind->status.description = ""; // TODO: b/34059183 1716 1717 return true; 1718 } 1719 1720 legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) { 1721 switch (type) { 1722 case RttType::ONE_SIDED: 1723 return legacy_hal::RTT_TYPE_1_SIDED; 1724 case RttType::TWO_SIDED: 1725 return legacy_hal::RTT_TYPE_2_SIDED; 1726 }; 1727 CHECK(false); 1728 } 1729 1730 RttType convertLegacyRttTypeToHidl(legacy_hal::wifi_rtt_type type) { 1731 switch (type) { 1732 case legacy_hal::RTT_TYPE_1_SIDED: 1733 return RttType::ONE_SIDED; 1734 case legacy_hal::RTT_TYPE_2_SIDED: 1735 return RttType::TWO_SIDED; 1736 }; 1737 CHECK(false) << "Unknown legacy type: " << type; 1738 } 1739 1740 legacy_hal::rtt_peer_type convertHidlRttPeerTypeToLegacy(RttPeerType type) { 1741 switch (type) { 1742 case RttPeerType::AP: 1743 return legacy_hal::RTT_PEER_AP; 1744 case RttPeerType::STA: 1745 return legacy_hal::RTT_PEER_STA; 1746 case RttPeerType::P2P_GO: 1747 return legacy_hal::RTT_PEER_P2P_GO; 1748 case RttPeerType::P2P_CLIENT: 1749 return legacy_hal::RTT_PEER_P2P_CLIENT; 1750 case RttPeerType::NAN: 1751 return legacy_hal::RTT_PEER_NAN; 1752 }; 1753 CHECK(false); 1754 } 1755 1756 legacy_hal::wifi_channel_width convertHidlWifiChannelWidthToLegacy( 1757 WifiChannelWidthInMhz type) { 1758 switch (type) { 1759 case WifiChannelWidthInMhz::WIDTH_20: 1760 return legacy_hal::WIFI_CHAN_WIDTH_20; 1761 case WifiChannelWidthInMhz::WIDTH_40: 1762 return legacy_hal::WIFI_CHAN_WIDTH_40; 1763 case WifiChannelWidthInMhz::WIDTH_80: 1764 return legacy_hal::WIFI_CHAN_WIDTH_80; 1765 case WifiChannelWidthInMhz::WIDTH_160: 1766 return legacy_hal::WIFI_CHAN_WIDTH_160; 1767 case WifiChannelWidthInMhz::WIDTH_80P80: 1768 return legacy_hal::WIFI_CHAN_WIDTH_80P80; 1769 case WifiChannelWidthInMhz::WIDTH_5: 1770 return legacy_hal::WIFI_CHAN_WIDTH_5; 1771 case WifiChannelWidthInMhz::WIDTH_10: 1772 return legacy_hal::WIFI_CHAN_WIDTH_10; 1773 case WifiChannelWidthInMhz::WIDTH_INVALID: 1774 return legacy_hal::WIFI_CHAN_WIDTH_INVALID; 1775 }; 1776 CHECK(false); 1777 } 1778 1779 WifiChannelWidthInMhz convertLegacyWifiChannelWidthToHidl( 1780 legacy_hal::wifi_channel_width type) { 1781 switch (type) { 1782 case legacy_hal::WIFI_CHAN_WIDTH_20: 1783 return WifiChannelWidthInMhz::WIDTH_20; 1784 case legacy_hal::WIFI_CHAN_WIDTH_40: 1785 return WifiChannelWidthInMhz::WIDTH_40; 1786 case legacy_hal::WIFI_CHAN_WIDTH_80: 1787 return WifiChannelWidthInMhz::WIDTH_80; 1788 case legacy_hal::WIFI_CHAN_WIDTH_160: 1789 return WifiChannelWidthInMhz::WIDTH_160; 1790 case legacy_hal::WIFI_CHAN_WIDTH_80P80: 1791 return WifiChannelWidthInMhz::WIDTH_80P80; 1792 case legacy_hal::WIFI_CHAN_WIDTH_5: 1793 return WifiChannelWidthInMhz::WIDTH_5; 1794 case legacy_hal::WIFI_CHAN_WIDTH_10: 1795 return WifiChannelWidthInMhz::WIDTH_10; 1796 case legacy_hal::WIFI_CHAN_WIDTH_INVALID: 1797 return WifiChannelWidthInMhz::WIDTH_INVALID; 1798 }; 1799 CHECK(false) << "Unknown legacy type: " << type; 1800 } 1801 1802 legacy_hal::wifi_rtt_preamble convertHidlRttPreambleToLegacy(RttPreamble type) { 1803 switch (type) { 1804 case RttPreamble::LEGACY: 1805 return legacy_hal::WIFI_RTT_PREAMBLE_LEGACY; 1806 case RttPreamble::HT: 1807 return legacy_hal::WIFI_RTT_PREAMBLE_HT; 1808 case RttPreamble::VHT: 1809 return legacy_hal::WIFI_RTT_PREAMBLE_VHT; 1810 }; 1811 CHECK(false); 1812 } 1813 1814 RttPreamble convertLegacyRttPreambleToHidl(legacy_hal::wifi_rtt_preamble type) { 1815 switch (type) { 1816 case legacy_hal::WIFI_RTT_PREAMBLE_LEGACY: 1817 return RttPreamble::LEGACY; 1818 case legacy_hal::WIFI_RTT_PREAMBLE_HT: 1819 return RttPreamble::HT; 1820 case legacy_hal::WIFI_RTT_PREAMBLE_VHT: 1821 return RttPreamble::VHT; 1822 }; 1823 CHECK(false) << "Unknown legacy type: " << type; 1824 } 1825 1826 legacy_hal::wifi_rtt_bw convertHidlRttBwToLegacy(RttBw type) { 1827 switch (type) { 1828 case RttBw::BW_5MHZ: 1829 return legacy_hal::WIFI_RTT_BW_5; 1830 case RttBw::BW_10MHZ: 1831 return legacy_hal::WIFI_RTT_BW_10; 1832 case RttBw::BW_20MHZ: 1833 return legacy_hal::WIFI_RTT_BW_20; 1834 case RttBw::BW_40MHZ: 1835 return legacy_hal::WIFI_RTT_BW_40; 1836 case RttBw::BW_80MHZ: 1837 return legacy_hal::WIFI_RTT_BW_80; 1838 case RttBw::BW_160MHZ: 1839 return legacy_hal::WIFI_RTT_BW_160; 1840 }; 1841 CHECK(false); 1842 } 1843 1844 RttBw convertLegacyRttBwToHidl(legacy_hal::wifi_rtt_bw type) { 1845 switch (type) { 1846 case legacy_hal::WIFI_RTT_BW_5: 1847 return RttBw::BW_5MHZ; 1848 case legacy_hal::WIFI_RTT_BW_10: 1849 return RttBw::BW_10MHZ; 1850 case legacy_hal::WIFI_RTT_BW_20: 1851 return RttBw::BW_20MHZ; 1852 case legacy_hal::WIFI_RTT_BW_40: 1853 return RttBw::BW_40MHZ; 1854 case legacy_hal::WIFI_RTT_BW_80: 1855 return RttBw::BW_80MHZ; 1856 case legacy_hal::WIFI_RTT_BW_160: 1857 return RttBw::BW_160MHZ; 1858 }; 1859 CHECK(false) << "Unknown legacy type: " << type; 1860 } 1861 1862 legacy_hal::wifi_motion_pattern convertHidlRttMotionPatternToLegacy( 1863 RttMotionPattern type) { 1864 switch (type) { 1865 case RttMotionPattern::NOT_EXPECTED: 1866 return legacy_hal::WIFI_MOTION_NOT_EXPECTED; 1867 case RttMotionPattern::EXPECTED: 1868 return legacy_hal::WIFI_MOTION_EXPECTED; 1869 case RttMotionPattern::UNKNOWN: 1870 return legacy_hal::WIFI_MOTION_UNKNOWN; 1871 }; 1872 CHECK(false); 1873 } 1874 1875 WifiRatePreamble convertLegacyWifiRatePreambleToHidl(uint8_t preamble) { 1876 switch (preamble) { 1877 case 0: 1878 return WifiRatePreamble::OFDM; 1879 case 1: 1880 return WifiRatePreamble::CCK; 1881 case 2: 1882 return WifiRatePreamble::HT; 1883 case 3: 1884 return WifiRatePreamble::VHT; 1885 default: 1886 return WifiRatePreamble::RESERVED; 1887 }; 1888 CHECK(false) << "Unknown legacy preamble: " << preamble; 1889 } 1890 1891 WifiRateNss convertLegacyWifiRateNssToHidl(uint8_t nss) { 1892 switch (nss) { 1893 case 0: 1894 return WifiRateNss::NSS_1x1; 1895 case 1: 1896 return WifiRateNss::NSS_2x2; 1897 case 2: 1898 return WifiRateNss::NSS_3x3; 1899 case 3: 1900 return WifiRateNss::NSS_4x4; 1901 }; 1902 CHECK(false) << "Unknown legacy nss: " << nss; 1903 return {}; 1904 } 1905 1906 RttStatus convertLegacyRttStatusToHidl(legacy_hal::wifi_rtt_status status) { 1907 switch (status) { 1908 case legacy_hal::RTT_STATUS_SUCCESS: 1909 return RttStatus::SUCCESS; 1910 case legacy_hal::RTT_STATUS_FAILURE: 1911 return RttStatus::FAILURE; 1912 case legacy_hal::RTT_STATUS_FAIL_NO_RSP: 1913 return RttStatus::FAIL_NO_RSP; 1914 case legacy_hal::RTT_STATUS_FAIL_REJECTED: 1915 return RttStatus::FAIL_REJECTED; 1916 case legacy_hal::RTT_STATUS_FAIL_NOT_SCHEDULED_YET: 1917 return RttStatus::FAIL_NOT_SCHEDULED_YET; 1918 case legacy_hal::RTT_STATUS_FAIL_TM_TIMEOUT: 1919 return RttStatus::FAIL_TM_TIMEOUT; 1920 case legacy_hal::RTT_STATUS_FAIL_AP_ON_DIFF_CHANNEL: 1921 return RttStatus::FAIL_AP_ON_DIFF_CHANNEL; 1922 case legacy_hal::RTT_STATUS_FAIL_NO_CAPABILITY: 1923 return RttStatus::FAIL_NO_CAPABILITY; 1924 case legacy_hal::RTT_STATUS_ABORTED: 1925 return RttStatus::ABORTED; 1926 case legacy_hal::RTT_STATUS_FAIL_INVALID_TS: 1927 return RttStatus::FAIL_INVALID_TS; 1928 case legacy_hal::RTT_STATUS_FAIL_PROTOCOL: 1929 return RttStatus::FAIL_PROTOCOL; 1930 case legacy_hal::RTT_STATUS_FAIL_SCHEDULE: 1931 return RttStatus::FAIL_SCHEDULE; 1932 case legacy_hal::RTT_STATUS_FAIL_BUSY_TRY_LATER: 1933 return RttStatus::FAIL_BUSY_TRY_LATER; 1934 case legacy_hal::RTT_STATUS_INVALID_REQ: 1935 return RttStatus::INVALID_REQ; 1936 case legacy_hal::RTT_STATUS_NO_WIFI: 1937 return RttStatus::NO_WIFI; 1938 case legacy_hal::RTT_STATUS_FAIL_FTM_PARAM_OVERRIDE: 1939 return RttStatus::FAIL_FTM_PARAM_OVERRIDE; 1940 }; 1941 CHECK(false) << "Unknown legacy status: " << status; 1942 } 1943 1944 bool convertHidlWifiChannelInfoToLegacy( 1945 const WifiChannelInfo& hidl_info, 1946 legacy_hal::wifi_channel_info* legacy_info) { 1947 if (!legacy_info) { 1948 return false; 1949 } 1950 *legacy_info = {}; 1951 legacy_info->width = convertHidlWifiChannelWidthToLegacy(hidl_info.width); 1952 legacy_info->center_freq = hidl_info.centerFreq; 1953 legacy_info->center_freq0 = hidl_info.centerFreq0; 1954 legacy_info->center_freq1 = hidl_info.centerFreq1; 1955 return true; 1956 } 1957 1958 bool convertLegacyWifiChannelInfoToHidl( 1959 const legacy_hal::wifi_channel_info& legacy_info, 1960 WifiChannelInfo* hidl_info) { 1961 if (!hidl_info) { 1962 return false; 1963 } 1964 *hidl_info = {}; 1965 hidl_info->width = convertLegacyWifiChannelWidthToHidl(legacy_info.width); 1966 hidl_info->centerFreq = legacy_info.center_freq; 1967 hidl_info->centerFreq0 = legacy_info.center_freq0; 1968 hidl_info->centerFreq1 = legacy_info.center_freq1; 1969 return true; 1970 } 1971 1972 bool convertHidlRttConfigToLegacy(const RttConfig& hidl_config, 1973 legacy_hal::wifi_rtt_config* legacy_config) { 1974 if (!legacy_config) { 1975 return false; 1976 } 1977 *legacy_config = {}; 1978 CHECK(hidl_config.addr.size() == sizeof(legacy_config->addr)); 1979 memcpy(legacy_config->addr, hidl_config.addr.data(), hidl_config.addr.size()); 1980 legacy_config->type = convertHidlRttTypeToLegacy(hidl_config.type); 1981 legacy_config->peer = convertHidlRttPeerTypeToLegacy(hidl_config.peer); 1982 if (!convertHidlWifiChannelInfoToLegacy(hidl_config.channel, 1983 &legacy_config->channel)) { 1984 return false; 1985 } 1986 legacy_config->burst_period = hidl_config.burstPeriod; 1987 legacy_config->num_burst = hidl_config.numBurst; 1988 legacy_config->num_frames_per_burst = hidl_config.numFramesPerBurst; 1989 legacy_config->num_retries_per_rtt_frame = hidl_config.numRetriesPerRttFrame; 1990 legacy_config->num_retries_per_ftmr = hidl_config.numRetriesPerFtmr; 1991 legacy_config->LCI_request = hidl_config.mustRequestLci; 1992 legacy_config->LCR_request = hidl_config.mustRequestLcr; 1993 legacy_config->burst_duration = hidl_config.burstDuration; 1994 legacy_config->preamble = 1995 convertHidlRttPreambleToLegacy(hidl_config.preamble); 1996 legacy_config->bw = convertHidlRttBwToLegacy(hidl_config.bw); 1997 return true; 1998 } 1999 2000 bool convertHidlVectorOfRttConfigToLegacy( 2001 const std::vector<RttConfig>& hidl_configs, 2002 std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) { 2003 if (!legacy_configs) { 2004 return false; 2005 } 2006 *legacy_configs = {}; 2007 for (const auto& hidl_config : hidl_configs) { 2008 legacy_hal::wifi_rtt_config legacy_config; 2009 if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) { 2010 return false; 2011 } 2012 legacy_configs->push_back(legacy_config); 2013 } 2014 return true; 2015 } 2016 2017 bool convertHidlRttLciInformationToLegacy( 2018 const RttLciInformation& hidl_info, 2019 legacy_hal::wifi_lci_information* legacy_info) { 2020 if (!legacy_info) { 2021 return false; 2022 } 2023 *legacy_info = {}; 2024 legacy_info->latitude = hidl_info.latitude; 2025 legacy_info->longitude = hidl_info.longitude; 2026 legacy_info->altitude = hidl_info.altitude; 2027 legacy_info->latitude_unc = hidl_info.latitudeUnc; 2028 legacy_info->longitude_unc = hidl_info.longitudeUnc; 2029 legacy_info->altitude_unc = hidl_info.altitudeUnc; 2030 legacy_info->motion_pattern = 2031 convertHidlRttMotionPatternToLegacy(hidl_info.motionPattern); 2032 legacy_info->floor = hidl_info.floor; 2033 legacy_info->height_above_floor = hidl_info.heightAboveFloor; 2034 legacy_info->height_unc = hidl_info.heightUnc; 2035 return true; 2036 } 2037 2038 bool convertHidlRttLcrInformationToLegacy( 2039 const RttLcrInformation& hidl_info, 2040 legacy_hal::wifi_lcr_information* legacy_info) { 2041 if (!legacy_info) { 2042 return false; 2043 } 2044 *legacy_info = {}; 2045 CHECK(hidl_info.countryCode.size() == sizeof(legacy_info->country_code)); 2046 memcpy(legacy_info->country_code, 2047 hidl_info.countryCode.data(), 2048 hidl_info.countryCode.size()); 2049 if (hidl_info.civicInfo.size() > sizeof(legacy_info->civic_info)) { 2050 return false; 2051 } 2052 legacy_info->length = hidl_info.civicInfo.size(); 2053 memcpy(legacy_info->civic_info, 2054 hidl_info.civicInfo.c_str(), 2055 hidl_info.civicInfo.size()); 2056 return true; 2057 } 2058 2059 bool convertHidlRttResponderToLegacy( 2060 const RttResponder& hidl_responder, 2061 legacy_hal::wifi_rtt_responder* legacy_responder) { 2062 if (!legacy_responder) { 2063 return false; 2064 } 2065 *legacy_responder = {}; 2066 if (!convertHidlWifiChannelInfoToLegacy(hidl_responder.channel, 2067 &legacy_responder->channel)) { 2068 return false; 2069 } 2070 legacy_responder->preamble = 2071 convertHidlRttPreambleToLegacy(hidl_responder.preamble); 2072 return true; 2073 } 2074 2075 bool convertLegacyRttResponderToHidl( 2076 const legacy_hal::wifi_rtt_responder& legacy_responder, 2077 RttResponder* hidl_responder) { 2078 if (!hidl_responder) { 2079 return false; 2080 } 2081 *hidl_responder = {}; 2082 if (!convertLegacyWifiChannelInfoToHidl(legacy_responder.channel, 2083 &hidl_responder->channel)) { 2084 return false; 2085 } 2086 hidl_responder->preamble = 2087 convertLegacyRttPreambleToHidl(legacy_responder.preamble); 2088 return true; 2089 } 2090 2091 bool convertLegacyRttCapabilitiesToHidl( 2092 const legacy_hal::wifi_rtt_capabilities& legacy_capabilities, 2093 RttCapabilities* hidl_capabilities) { 2094 if (!hidl_capabilities) { 2095 return false; 2096 } 2097 *hidl_capabilities = {}; 2098 hidl_capabilities->rttOneSidedSupported = 2099 legacy_capabilities.rtt_one_sided_supported; 2100 hidl_capabilities->rttFtmSupported = legacy_capabilities.rtt_ftm_supported; 2101 hidl_capabilities->lciSupported = legacy_capabilities.lci_support; 2102 hidl_capabilities->lcrSupported = legacy_capabilities.lcr_support; 2103 hidl_capabilities->responderSupported = 2104 legacy_capabilities.responder_supported; 2105 hidl_capabilities->preambleSupport = 0; 2106 for (const auto flag : {legacy_hal::WIFI_RTT_PREAMBLE_LEGACY, 2107 legacy_hal::WIFI_RTT_PREAMBLE_HT, 2108 legacy_hal::WIFI_RTT_PREAMBLE_VHT}) { 2109 if (legacy_capabilities.preamble_support & flag) { 2110 hidl_capabilities->preambleSupport |= 2111 static_cast<std::underlying_type<RttPreamble>::type>( 2112 convertLegacyRttPreambleToHidl(flag)); 2113 } 2114 } 2115 hidl_capabilities->bwSupport = 0; 2116 for (const auto flag : {legacy_hal::WIFI_RTT_BW_5, 2117 legacy_hal::WIFI_RTT_BW_10, 2118 legacy_hal::WIFI_RTT_BW_20, 2119 legacy_hal::WIFI_RTT_BW_40, 2120 legacy_hal::WIFI_RTT_BW_80, 2121 legacy_hal::WIFI_RTT_BW_160}) { 2122 if (legacy_capabilities.bw_support & flag) { 2123 hidl_capabilities->bwSupport |= 2124 static_cast<std::underlying_type<RttBw>::type>( 2125 convertLegacyRttBwToHidl(flag)); 2126 } 2127 } 2128 hidl_capabilities->mcVersion = legacy_capabilities.mc_version; 2129 return true; 2130 } 2131 2132 bool convertLegacyWifiRateInfoToHidl(const legacy_hal::wifi_rate& legacy_rate, 2133 WifiRateInfo* hidl_rate) { 2134 if (!hidl_rate) { 2135 return false; 2136 } 2137 *hidl_rate = {}; 2138 hidl_rate->preamble = 2139 convertLegacyWifiRatePreambleToHidl(legacy_rate.preamble); 2140 hidl_rate->nss = convertLegacyWifiRateNssToHidl(legacy_rate.nss); 2141 hidl_rate->bw = convertLegacyWifiChannelWidthToHidl( 2142 static_cast<legacy_hal::wifi_channel_width>(legacy_rate.bw)); 2143 hidl_rate->rateMcsIdx = legacy_rate.rateMcsIdx; 2144 hidl_rate->bitRateInKbps = legacy_rate.bitrate; 2145 return true; 2146 } 2147 2148 bool convertLegacyRttResultToHidl( 2149 const legacy_hal::wifi_rtt_result& legacy_result, RttResult* hidl_result) { 2150 if (!hidl_result) { 2151 return false; 2152 } 2153 *hidl_result = {}; 2154 CHECK(sizeof(legacy_result.addr) == hidl_result->addr.size()); 2155 memcpy( 2156 hidl_result->addr.data(), legacy_result.addr, sizeof(legacy_result.addr)); 2157 hidl_result->burstNum = legacy_result.burst_num; 2158 hidl_result->measurementNumber = legacy_result.measurement_number; 2159 hidl_result->successNumber = legacy_result.success_number; 2160 hidl_result->numberPerBurstPeer = legacy_result.number_per_burst_peer; 2161 hidl_result->status = convertLegacyRttStatusToHidl(legacy_result.status); 2162 hidl_result->retryAfterDuration = legacy_result.retry_after_duration; 2163 hidl_result->type = convertLegacyRttTypeToHidl(legacy_result.type); 2164 hidl_result->rssi = legacy_result.rssi; 2165 hidl_result->rssiSpread = legacy_result.rssi_spread; 2166 if (!convertLegacyWifiRateInfoToHidl(legacy_result.tx_rate, 2167 &hidl_result->txRate)) { 2168 return false; 2169 } 2170 if (!convertLegacyWifiRateInfoToHidl(legacy_result.rx_rate, 2171 &hidl_result->rxRate)) { 2172 return false; 2173 } 2174 hidl_result->rtt = legacy_result.rtt; 2175 hidl_result->rttSd = legacy_result.rtt_sd; 2176 hidl_result->rttSpread = legacy_result.rtt_spread; 2177 hidl_result->distanceInMm = legacy_result.distance_mm; 2178 hidl_result->distanceSdInMm = legacy_result.distance_sd_mm; 2179 hidl_result->distanceSpreadInMm = legacy_result.distance_spread_mm; 2180 hidl_result->timeStampInUs = legacy_result.ts; 2181 hidl_result->burstDurationInMs = legacy_result.burst_duration; 2182 hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num; 2183 if (legacy_result.LCI && !convertLegacyIeToHidl(*legacy_result.LCI, 2184 &hidl_result->lci)) { 2185 return false; 2186 } 2187 if (legacy_result.LCR && !convertLegacyIeToHidl(*legacy_result.LCR, 2188 &hidl_result->lcr)) { 2189 return false; 2190 } 2191 return true; 2192 } 2193 2194 bool convertLegacyVectorOfRttResultToHidl( 2195 const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results, 2196 std::vector<RttResult>* hidl_results) { 2197 if (!hidl_results) { 2198 return false; 2199 } 2200 *hidl_results = {}; 2201 for (const auto legacy_result : legacy_results) { 2202 RttResult hidl_result; 2203 if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) { 2204 return false; 2205 } 2206 hidl_results->push_back(hidl_result); 2207 } 2208 return true; 2209 } 2210 } // namespace hidl_struct_util 2211 } // namespace implementation 2212 } // namespace V1_1 2213 } // namespace wifi 2214 } // namespace hardware 2215 } // namespace android 2216
