wifi/1.0/default/hidl_struct_util.cpp

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