summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'wifi/1.2/default/hidl_struct_util.cpp')
-rw-r--r--wifi/1.2/default/hidl_struct_util.cpp2215
1 files changed, 2215 insertions, 0 deletions
diff --git a/wifi/1.2/default/hidl_struct_util.cpp b/wifi/1.2/default/hidl_struct_util.cpp
new file mode 100644
index 00000000..1ad838be
--- /dev/null
+++ b/wifi/1.2/default/hidl_struct_util.cpp
@@ -0,0 +1,2215 @@
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
22namespace android {
23namespace hardware {
24namespace wifi {
25namespace V1_2 {
26namespace implementation {
27namespace hidl_struct_util {
28
29hidl_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
39IWifiChip::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
58IWifiStaIface::StaIfaceCapabilityMask
59convertLegacyLoggerFeatureToHidlStaIfaceCapability(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
69V1_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
84IWifiStaIface::StaIfaceCapabilityMask
85convertLegacyFeatureToHidlStaIfaceCapability(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
119bool 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
152WifiDebugRingBufferFlags 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
164bool 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
198bool 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
216bool 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
260legacy_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
269bool 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
306bool 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
318uint8_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
332StaScanDataFlagMask 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
343bool 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
357legacy_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
377bool 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
433bool 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
446bool 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
484bool 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
517bool 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
553bool 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
572WifiDebugTxPacketFate 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
599WifiDebugRxPacketFate 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
628WifiDebugPacketFateFrameType 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
641bool 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
660bool 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
672bool 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
689bool 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
701bool 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
718bool 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
778bool 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
790bool 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
818legacy_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
829legacy_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
841legacy_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
853legacy_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
863legacy_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
873legacy_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
883legacy_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
896NanStatusType 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
929void 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
935bool 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
1072bool 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
1189bool 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
1317bool 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
1356bool 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
1453bool 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
1519bool 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
1583bool 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
1597bool 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
1625bool 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
1658bool 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
1680bool 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
1700bool 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
1720legacy_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
1730RttType 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
1740legacy_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
1756legacy_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
1779WifiChannelWidthInMhz 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
1802legacy_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
1814RttPreamble 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
1826legacy_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
1844RttBw 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
1862legacy_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
1875WifiRatePreamble 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
1891WifiRateNss 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
1906RttStatus 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
1944bool 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
1958bool 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
1972bool 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
2000bool 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
2017bool 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
2038bool 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
2059bool 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
2075bool 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
2091bool 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
2132bool 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
2148bool 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
2194bool 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_2
2213} // namespace wifi
2214} // namespace hardware
2215} // namespace android