[AWARE] Update HIDL interface and link to legacy HAL

HAL: Refine first cut implementation of HIDL interfaces and bring
up-to-date with changes to HAL.

Server: connect to legacy HAL, convert all structures.

Bug: 32207606
Test: builds
Change-Id: Ice1ba44014aa98cc948c0d0202b4fd18bf875502

1 files changed, 519 insertions, 384 deletions

diff --git a/wifi/1.0/default/hidl_struct_util.cpp b/wifi/1.0/default/hidl_struct_util.cpp
index a94d812d1a..9cc57bb5f1 100644
--- a/wifi/1.0/default/hidl_struct_util.cpp
+++ b/wifi/1.0/default/hidl_struct_util.cpp
@@ -743,123 +743,10 @@ legacy_hal::fw_roaming_state_t convertHidlRoamingStateToLegacy(
   CHECK(false);
 }
 
-legacy_hal::NanPublishType convertHidlNanPublishTypeToLegacy(
-    NanPublishType type) {
-  switch (type) {
-    case NanPublishType::UNSOLICITED:
-      return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED;
-    case NanPublishType::SOLICITED:
-      return legacy_hal::NAN_PUBLISH_TYPE_SOLICITED;
-    case NanPublishType::UNSOLICITED_SOLICITED:
-      return legacy_hal::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED;
-  };
-  CHECK(false);
-}
-
-legacy_hal::NanTxType convertHidlNanTxTypeToLegacy(NanTxType type) {
-  switch (type) {
-    case NanTxType::BROADCAST:
-      return legacy_hal::NAN_TX_TYPE_BROADCAST;
-    case NanTxType::UNICAST:
-      return legacy_hal::NAN_TX_TYPE_UNICAST;
-  };
-  CHECK(false);
-}
-
-legacy_hal::NanMatchAlg convertHidlNanMatchAlgToLegacy(NanMatchAlg type) {
-  switch (type) {
-    case NanMatchAlg::MATCH_ONCE:
-      return legacy_hal::NAN_MATCH_ALG_MATCH_ONCE;
-    case NanMatchAlg::MATCH_CONTINUOUS:
-      return legacy_hal::NAN_MATCH_ALG_MATCH_CONTINUOUS;
-    case NanMatchAlg::MATCH_NEVER:
-      return legacy_hal::NAN_MATCH_ALG_MATCH_NEVER;
-  };
-  CHECK(false);
-}
-
-legacy_hal::NanSubscribeType convertHidlNanSubscribeTypeToLegacy(
-    NanSubscribeType type) {
-  switch (type) {
-    case NanSubscribeType::ACTIVE:
-      return legacy_hal::NAN_SUBSCRIBE_TYPE_ACTIVE;
-    case NanSubscribeType::PASSIVE:
-      return legacy_hal::NAN_SUBSCRIBE_TYPE_PASSIVE;
-  };
-  CHECK(false);
-}
-
-legacy_hal::NanSRFType convertHidlNanSrfTypeToLegacy(NanSrfType type) {
-  switch (type) {
-    case NanSrfType::BLOOM_FILTER:
-      return legacy_hal::NAN_SRF_ATTR_BLOOM_FILTER;
-    case NanSrfType::PARTIAL_MAC_ADDR:
-      return legacy_hal::NAN_SRF_ATTR_PARTIAL_MAC_ADDR;
-  };
-  CHECK(false);
-}
-
-legacy_hal::NanSRFIncludeType convertHidlNanSrfIncludeTypeToLegacy(
-    NanSrfIncludeType type) {
-  switch (type) {
-    case NanSrfIncludeType::DO_NOT_RESPOND:
-      return legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
-    case NanSrfIncludeType::RESPOND:
-      return legacy_hal::NAN_SRF_INCLUDE_RESPOND;
-  };
-  CHECK(false);
-}
-
 NanStatusType convertLegacyNanStatusTypeToHidl(
-    legacy_hal::NanStatusType /* type */) {
-  // TODO: The |NanStatusType| has changed in legacy HAL and no longer in sync
-  // with the HIDL interface.
-  return NanStatusType::SUCCESS;
-}
-
-NanResponseType convertLegacyNanResponseTypeToHidl(
-    legacy_hal::NanResponseType type) {
-  switch (type) {
-    case legacy_hal::NAN_RESPONSE_ENABLED:
-      return NanResponseType::ENABLED;
-    case legacy_hal::NAN_RESPONSE_DISABLED:
-      return NanResponseType::DISABLED;
-    case legacy_hal::NAN_RESPONSE_PUBLISH:
-      return NanResponseType::PUBLISH;
-    case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL:
-      return NanResponseType::PUBLISH_CANCEL;
-    case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP:
-      return NanResponseType::TRANSMIT_FOLLOWUP;
-    case legacy_hal::NAN_RESPONSE_SUBSCRIBE:
-      return NanResponseType::SUBSCRIBE;
-    case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL:
-      return NanResponseType::SUBSCRIBE_CANCEL;
-    case legacy_hal::NAN_RESPONSE_STATS:
-      // Not present in HIDL. Is going to be deprecated in legacy HAL as well.
-      CHECK(0);
-    case legacy_hal::NAN_RESPONSE_CONFIG:
-      return NanResponseType::CONFIG;
-    case legacy_hal::NAN_RESPONSE_TCA:
-      // Not present in HIDL. Is going to be deprecated in legacy HAL as well.
-      CHECK(0);
-    case legacy_hal::NAN_RESPONSE_ERROR:
-      return NanResponseType::ERROR;
-    case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD:
-      return NanResponseType::BEACON_SDF_PAYLOAD;
-    case legacy_hal::NAN_GET_CAPABILITIES:
-      return NanResponseType::GET_CAPABILITIES;
-    case legacy_hal::NAN_DP_INTERFACE_CREATE:
-      return NanResponseType::DP_INTERFACE_CREATE;
-    case legacy_hal::NAN_DP_INTERFACE_DELETE:
-      return NanResponseType::DP_INTERFACE_DELETE;
-    case legacy_hal::NAN_DP_INITIATOR_RESPONSE:
-      return NanResponseType::DP_INITIATOR_RESPONSE;
-    case legacy_hal::NAN_DP_RESPONDER_RESPONSE:
-      return NanResponseType::DP_RESPONDER_RESPONSE;
-    case legacy_hal::NAN_DP_END:
-      return NanResponseType::DP_END;
-  };
-  CHECK(false) << "Unknown legacy type: " << type;
+    legacy_hal::NanStatusType type) {
+  // values are identical - may need to do a mapping if they diverge in the future
+  return (NanStatusType) type;
 }
 
 bool convertHidlNanEnableRequestToLegacy(
@@ -868,79 +755,123 @@ bool convertHidlNanEnableRequestToLegacy(
   if (!legacy_request) {
     return false;
   }
-  legacy_request->master_pref = hidl_request.masterPref;
-  legacy_request->cluster_low = hidl_request.clusterLow;
-  legacy_request->cluster_high = hidl_request.clusterHigh;
-  legacy_request->config_support_5g = hidl_request.validSupport5gVal;
-  legacy_request->support_5g_val = hidl_request.support5gVal;
-  legacy_request->config_sid_beacon = hidl_request.validSidBeaconVal;
-  legacy_request->sid_beacon_val = hidl_request.sidBeaconVal;
-  legacy_request->config_2dot4g_rssi_close =
-      hidl_request.valid2dot4gRssiCloseVal;
-  legacy_request->rssi_close_2dot4g_val = hidl_request.rssiClose2dot4gVal;
-  legacy_request->config_2dot4g_rssi_middle =
-      hidl_request.valid2dot4gRssiMiddleVal;
-  legacy_request->rssi_middle_2dot4g_val = hidl_request.rssiMiddle2dot4gVal;
-  legacy_request->config_2dot4g_rssi_proximity =
-      hidl_request.valid2dot4gRssiProximityVal;
+  memset(legacy_request, 0, sizeof(legacy_hal::NanEnableRequest));
+
+  // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown defaults
+  legacy_request->config_2dot4g_support = 1;
+  legacy_request->support_2dot4g_val = hidl_request.operateInBand[
+        (size_t) NanBandIndex::NAN_BAND_24GHZ];
+  legacy_request->config_support_5g = 1;
+  legacy_request->support_5g_val = hidl_request.operateInBand[(size_t) NanBandIndex::NAN_BAND_5GHZ];
+  legacy_request->config_hop_count_limit = 0; // TODO: don't know default yet
+  legacy_request->hop_count_limit_val = hidl_request.hopCountMax;
+  legacy_request->master_pref = hidl_request.configParams.masterPref;
+  legacy_request->discovery_indication_cfg = 0;
+  legacy_request->discovery_indication_cfg |=
+        hidl_request.configParams.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
+  legacy_request->discovery_indication_cfg |=
+        hidl_request.configParams.disableStartedClusterIndication ? 0x2 : 0x0;
+  legacy_request->discovery_indication_cfg |=
+        hidl_request.configParams.disableJoinedClusterIndication ? 0x4 : 0x0;
+  legacy_request->config_sid_beacon = 1;
+  if (hidl_request.configParams.numberOfServiceIdsInBeacon > 127) {
+    return false;
+  }
+  legacy_request->sid_beacon_val = (hidl_request.configParams.includeServiceIdsInBeacon ? 0x1 : 0x0)
+        | (hidl_request.configParams.numberOfServiceIdsInBeacon << 1);
+  legacy_request->config_rssi_window_size = 0; // TODO: don't know default yet
+  legacy_request->rssi_window_size_val = hidl_request.configParams.rssiWindowSize;
+  legacy_request->config_disc_mac_addr_randomization = 1;
+  legacy_request->disc_mac_addr_rand_interval_sec =
+        hidl_request.configParams.macAddressRandomizationIntervalSec;
+  legacy_request->config_responder_auto_response = 1;
+  legacy_request->ranging_auto_response_cfg = hidl_request.configParams.acceptRangingRequests ?
+       legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
+  legacy_request->config_2dot4g_rssi_close = 0; // TODO: don't know default yet
+  legacy_request->rssi_close_2dot4g_val =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
+  legacy_request->config_2dot4g_rssi_middle = 0; // TODO: don't know default yet
+  legacy_request->rssi_middle_2dot4g_val =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
+  legacy_request->config_2dot4g_rssi_proximity = 0; // TODO: don't know default yet
   legacy_request->rssi_proximity_2dot4g_val =
-      hidl_request.rssiProximity2dot4gVal;
-  legacy_request->config_hop_count_limit = hidl_request.validHopCountLimitVal;
-  legacy_request->hop_count_limit_val = hidl_request.hopCountLimitVal;
-  legacy_request->config_2dot4g_support = hidl_request.valid2dot4gSupportVal;
-  legacy_request->support_2dot4g_val = hidl_request.support2dot4gVal;
-  legacy_request->config_2dot4g_beacons = hidl_request.valid2dot4gBeaconsVal;
-  legacy_request->beacon_2dot4g_val = hidl_request.beacon2dot4gVal;
-  legacy_request->config_2dot4g_sdf = hidl_request.valid2dot4gSdfVal;
-  legacy_request->sdf_2dot4g_val = hidl_request.sdf2dot4gVal;
-  legacy_request->config_5g_beacons = hidl_request.valid5gBeaconsVal;
-  legacy_request->beacon_5g_val = hidl_request.beacon5gVal;
-  legacy_request->config_5g_sdf = hidl_request.valid5gSdfVal;
-  legacy_request->sdf_5g_val = hidl_request.sdf5gVal;
-  legacy_request->config_5g_rssi_close = hidl_request.valid5gRssiCloseVal;
-  legacy_request->rssi_close_5g_val = hidl_request.rssiClose5gVal;
-  legacy_request->config_5g_rssi_middle = hidl_request.valid5gRssiMiddleVal;
-  legacy_request->rssi_middle_5g_val = hidl_request.rssiMiddle5gVal;
-  legacy_request->config_5g_rssi_close_proximity =
-      hidl_request.valid5gRssiCloseProximityVal;
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiProximity;
+  legacy_request->config_scan_params = 0; // TODO: don't know default yet
+  legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
+  legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
+  legacy_request->config_dw.config_2dot4g_dw_band = hidl_request.configParams
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal;
+  legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request.configParams
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal;
+  legacy_request->config_5g_rssi_close = 0; // TODO: don't know default yet
+  legacy_request->rssi_close_5g_val =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
+  legacy_request->config_5g_rssi_middle = 0; // TODO: don't know default yet
+  legacy_request->rssi_middle_5g_val =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
+  legacy_request->config_5g_rssi_close_proximity = 0; // TODO: don't know default yet
   legacy_request->rssi_close_proximity_5g_val =
-      hidl_request.rssiCloseProximity5gVal;
-  legacy_request->config_rssi_window_size = hidl_request.validRssiWindowSizeVal;
-  legacy_request->rssi_window_size_val = hidl_request.rssiWindowSizeVal;
-  legacy_request->config_oui = hidl_request.validOuiVal;
-  legacy_request->oui_val = hidl_request.ouiVal;
-  legacy_request->config_intf_addr = hidl_request.validIntfAddrVal;
-  CHECK(hidl_request.intfAddrVal.size() ==
-        sizeof(legacy_request->intf_addr_val));
-  memcpy(legacy_request->intf_addr_val,
-         hidl_request.intfAddrVal.data(),
-         hidl_request.intfAddrVal.size());
-  legacy_request->config_cluster_attribute_val =
-      hidl_request.configClusterAttributeVal;
-  legacy_request->config_scan_params = hidl_request.validScanParamsVal;
-  if (hidl_request.scanParamsVal.dwellTime.size() >
-      sizeof(legacy_request->scan_params_val.dwell_time)) {
-    return false;
-  }
-  memcpy(legacy_request->scan_params_val.dwell_time,
-         hidl_request.scanParamsVal.dwellTime.data(),
-         hidl_request.scanParamsVal.dwellTime.size());
-  if (hidl_request.scanParamsVal.scanPeriod.size() >
-      sizeof(legacy_request->scan_params_val.scan_period)) {
-    return false;
-  }
-  memcpy(legacy_request->scan_params_val.scan_period,
-         hidl_request.scanParamsVal.scanPeriod.data(),
-         hidl_request.scanParamsVal.scanPeriod.size());
-  legacy_request->config_random_factor_force =
-      hidl_request.validRandomFactorForceVal;
-  legacy_request->random_factor_force_val = hidl_request.randomFactorForceVal;
-  legacy_request->config_hop_count_force = hidl_request.validHopCountLimitVal;
-  legacy_request->hop_count_force_val = hidl_request.hopCountLimitVal;
-  legacy_request->config_24g_channel = hidl_request.valid24gChannelVal;
-  legacy_request->channel_24g_val = hidl_request.channel24gVal;
-  legacy_request->config_5g_channel = hidl_request.valid5gChannelVal;
-  legacy_request->channel_5g_val = hidl_request.channel5gVal;
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiProximity;
+  legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
+  legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
+  legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
+  legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+        hidl_request.configParams.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
+  legacy_request->config_dw.config_5g_dw_band = hidl_request.configParams
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal;
+  legacy_request->config_dw.dw_5g_interval_val = hidl_request.configParams
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal;
+  if (hidl_request.debugConfigs.validClusterIdVals) {
+    legacy_request->cluster_low = hidl_request.debugConfigs.clusterIdLowVal;
+    legacy_request->cluster_high = hidl_request.debugConfigs.clusterIdHighVal;
+  } else { // need 'else' since not configurable in legacy HAL
+    legacy_request->cluster_low = 0x0000;
+    legacy_request->cluster_high = 0xFFFF;
+  }
+  legacy_request->config_intf_addr = hidl_request.debugConfigs.validIntfAddrVal;
+  memcpy(legacy_request->intf_addr_val, hidl_request.debugConfigs.intfAddrVal.data(), 6);
+  legacy_request->config_oui = hidl_request.debugConfigs.validOuiVal;
+  legacy_request->oui_val = hidl_request.debugConfigs.ouiVal;
+  legacy_request->config_random_factor_force = hidl_request.debugConfigs.validRandomFactorForceVal;
+  legacy_request->random_factor_force_val = hidl_request.debugConfigs.randomFactorForceVal;
+  legacy_request->config_hop_count_force = hidl_request.debugConfigs.validHopCountForceVal;
+  legacy_request->hop_count_force_val = hidl_request.debugConfigs.hopCountForceVal;
+  legacy_request->config_24g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
+  legacy_request->channel_24g_val =
+        hidl_request.debugConfigs.discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
+  legacy_request->config_5g_channel = hidl_request.debugConfigs.validDiscoveryChannelVal;
+  legacy_request->channel_5g_val = hidl_request.debugConfigs
+        .discoveryChannelMhzVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
+  legacy_request->config_2dot4g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
+  legacy_request->beacon_2dot4g_val = hidl_request.debugConfigs
+        .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
+  legacy_request->config_5g_beacons = hidl_request.debugConfigs.validUseBeaconsInBandVal;
+  legacy_request->beacon_5g_val = hidl_request.debugConfigs
+        .useBeaconsInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
+  legacy_request->config_2dot4g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
+  legacy_request->sdf_2dot4g_val = hidl_request.debugConfigs
+        .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_24GHZ];
+  legacy_request->config_5g_sdf = hidl_request.debugConfigs.validUseSdfInBandVal;
+  legacy_request->sdf_5g_val = hidl_request.debugConfigs
+        .useSdfInBandVal[(size_t) NanBandIndex::NAN_BAND_5GHZ];
+
   return true;
 }
 
@@ -950,57 +881,69 @@ bool convertHidlNanPublishRequestToLegacy(
   if (!legacy_request) {
     return false;
   }
-  legacy_request->publish_id = hidl_request.publishId;
-  legacy_request->ttl = hidl_request.ttl;
-  legacy_request->period = hidl_request.period;
-  legacy_request->publish_type =
-      convertHidlNanPublishTypeToLegacy(hidl_request.publishType);
-  legacy_request->tx_type = convertHidlNanTxTypeToLegacy(hidl_request.txType);
-  legacy_request->publish_count = hidl_request.publishCount;
-  if (hidl_request.serviceName.size() > sizeof(legacy_request->service_name)) {
+  memset(&legacy_request, 0, sizeof(legacy_hal::NanPublishRequest));
+
+  legacy_request->publish_id = hidl_request.baseConfigs.sessionId;
+  legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
+  legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
+  legacy_request->publish_count = hidl_request.baseConfigs.discoveryCount;
+  legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
+  if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
     return false;
   }
-  legacy_request->service_name_len = hidl_request.serviceName.size();
-  memcpy(legacy_request->service_name,
-         hidl_request.serviceName.c_str(),
-         hidl_request.serviceName.size());
+  memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.c_str(),
+        legacy_request->service_name_len);
   legacy_request->publish_match_indicator =
-      convertHidlNanMatchAlgToLegacy(hidl_request.publishMatchIndicator);
-  if (hidl_request.serviceSpecificInfo.size() >
-      sizeof(legacy_request->service_specific_info)) {
+        (legacy_hal::NanMatchAlg) hidl_request.baseConfigs.discoveryMatchIndicator;
+  legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
+  if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
     return false;
   }
-  legacy_request->service_specific_info_len =
-      hidl_request.serviceSpecificInfo.size();
   memcpy(legacy_request->service_specific_info,
-         hidl_request.serviceSpecificInfo.data(),
-         hidl_request.serviceSpecificInfo.size());
-  if (hidl_request.rxMatchFilter.size() >
-      sizeof(legacy_request->rx_match_filter)) {
+        hidl_request.baseConfigs.serviceSpecificInfo.data(),
+        legacy_request->service_specific_info_len);
+  legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
+  if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
     return false;
   }
-  legacy_request->rx_match_filter_len = hidl_request.rxMatchFilter.size();
   memcpy(legacy_request->rx_match_filter,
-         hidl_request.rxMatchFilter.data(),
-         hidl_request.rxMatchFilter.size());
-  if (hidl_request.txMatchFilter.size() >
-      sizeof(legacy_request->tx_match_filter)) {
+        hidl_request.baseConfigs.rxMatchFilter.data(),
+        legacy_request->rx_match_filter_len);
+  legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
+  if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
     return false;
   }
-  legacy_request->tx_match_filter_len = hidl_request.txMatchFilter.size();
   memcpy(legacy_request->tx_match_filter,
-         hidl_request.txMatchFilter.data(),
-         hidl_request.txMatchFilter.size());
-  legacy_request->rssi_threshold_flag = hidl_request.useRssiThreshold;
-  legacy_request->connmap = hidl_request.connmap;
-  legacy_request->recv_indication_cfg = hidl_request.recvIndicationCfg;
-  return true;
-}
+        hidl_request.baseConfigs.txMatchFilter.data(),
+        legacy_request->tx_match_filter_len);
+  legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
+  legacy_request->recv_indication_cfg = 0;
+  legacy_request->recv_indication_cfg |=
+        hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
+  legacy_request->recv_indication_cfg |=
+        hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
+  legacy_request->recv_indication_cfg |=
+        hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
+  legacy_request->cipher_type = hidl_request.baseConfigs.supportedCipherTypes;
+  legacy_request->pmk_len = hidl_request.baseConfigs.pmk.size();
+  if (legacy_request->pmk_len > NAN_PMK_INFO_LEN) {
+    return false;
+  }
+  memcpy(legacy_request->pmk,
+        hidl_request.baseConfigs.pmk.data(),
+        legacy_request->pmk_len);
+  legacy_request->sdea_params.security_cfg = hidl_request.baseConfigs.securityEnabledInNdp ?
+        legacy_hal::NAN_DP_CONFIG_SECURITY : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+  legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ?
+        legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE;
+  legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec;
+  legacy_request->ranging_cfg.config_ranging_indications =
+        hidl_request.baseConfigs.configRangingIndications;
+  legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm;
+  legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm;
+  legacy_request->publish_type = (legacy_hal::NanPublishType) hidl_request.publishType;
+  legacy_request->tx_type = (legacy_hal::NanTxType) hidl_request.txType;
 
-bool convertHidlNanPublishCancelRequestToLegacy(
-    const NanPublishCancelRequest& hidl_request,
-    legacy_hal::NanPublishCancelRequest* legacy_request) {
-  legacy_request->publish_id = hidl_request.publishId;
   return true;
 }
 
@@ -1010,225 +953,417 @@ bool convertHidlNanSubscribeRequestToLegacy(
   if (!legacy_request) {
     return false;
   }
-  legacy_request->subscribe_id = hidl_request.subscribeId;
-  legacy_request->ttl = hidl_request.ttl;
-  legacy_request->period = hidl_request.period;
-  legacy_request->subscribe_type =
-      convertHidlNanSubscribeTypeToLegacy(hidl_request.subscribeType);
-  legacy_request->serviceResponseFilter =
-      convertHidlNanSrfTypeToLegacy(hidl_request.serviceResponseFilter);
-  legacy_request->serviceResponseInclude =
-      convertHidlNanSrfIncludeTypeToLegacy(hidl_request.serviceResponseInclude);
-  legacy_request->useServiceResponseFilter =
-      hidl_request.shouldUseServiceResponseFilter
-          ? legacy_hal::NAN_USE_SRF
-          : legacy_hal::NAN_DO_NOT_USE_SRF;
-  legacy_request->ssiRequiredForMatchIndication =
-      hidl_request.isSsiRequiredForMatchIndication
-          ? legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND
-          : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
-  legacy_request->subscribe_match_indicator =
-      convertHidlNanMatchAlgToLegacy(hidl_request.subscribeMatchIndicator);
-  legacy_request->subscribe_count = hidl_request.subscribeCount;
-  if (hidl_request.serviceName.size() > sizeof(legacy_request->service_name)) {
+  memset(&legacy_request, 0, sizeof(legacy_hal::NanSubscribeRequest));
+
+  legacy_request->subscribe_id = hidl_request.baseConfigs.sessionId;
+  legacy_request->ttl = hidl_request.baseConfigs.ttlSec;
+  legacy_request->period = hidl_request.baseConfigs.discoveryWindowPeriod;
+  legacy_request->subscribe_count = hidl_request.baseConfigs.discoveryCount;
+  legacy_request->service_name_len = hidl_request.baseConfigs.serviceName.size();
+  if (legacy_request->service_name_len > NAN_MAX_SERVICE_NAME_LEN) {
     return false;
   }
-  legacy_request->service_name_len = hidl_request.serviceName.size();
-  memcpy(legacy_request->service_name,
-         hidl_request.serviceName.c_str(),
-         hidl_request.serviceName.size());
-  if (hidl_request.serviceSpecificInfo.size() >
-      sizeof(legacy_request->service_specific_info)) {
+  memcpy(legacy_request->service_name, hidl_request.baseConfigs.serviceName.c_str(),
+        legacy_request->service_name_len);
+  legacy_request->subscribe_match_indicator =
+        (legacy_hal::NanMatchAlg) hidl_request.baseConfigs.discoveryMatchIndicator;
+  legacy_request->service_specific_info_len = hidl_request.baseConfigs.serviceSpecificInfo.size();
+  if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
     return false;
   }
-  legacy_request->service_specific_info_len =
-      hidl_request.serviceSpecificInfo.size();
   memcpy(legacy_request->service_specific_info,
-         hidl_request.serviceSpecificInfo.data(),
-         hidl_request.serviceSpecificInfo.size());
-  if (hidl_request.rxMatchFilter.size() >
-      sizeof(legacy_request->rx_match_filter)) {
+        hidl_request.baseConfigs.serviceSpecificInfo.data(),
+        legacy_request->service_specific_info_len);
+  legacy_request->rx_match_filter_len = hidl_request.baseConfigs.rxMatchFilter.size();
+  if (legacy_request->rx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
     return false;
   }
-  legacy_request->rx_match_filter_len = hidl_request.rxMatchFilter.size();
   memcpy(legacy_request->rx_match_filter,
-         hidl_request.rxMatchFilter.data(),
-         hidl_request.rxMatchFilter.size());
-  if (hidl_request.txMatchFilter.size() >
-      sizeof(legacy_request->tx_match_filter)) {
+        hidl_request.baseConfigs.rxMatchFilter.data(),
+        legacy_request->rx_match_filter_len);
+  legacy_request->tx_match_filter_len = hidl_request.baseConfigs.txMatchFilter.size();
+  if (legacy_request->tx_match_filter_len > NAN_MAX_MATCH_FILTER_LEN) {
     return false;
   }
-  legacy_request->tx_match_filter_len = hidl_request.txMatchFilter.size();
   memcpy(legacy_request->tx_match_filter,
-         hidl_request.txMatchFilter.data(),
-         hidl_request.txMatchFilter.size());
-  legacy_request->rssi_threshold_flag = hidl_request.useRssiThreshold;
-  legacy_request->connmap = hidl_request.connmap;
-  if (hidl_request.intfAddr.size() > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
+        hidl_request.baseConfigs.txMatchFilter.data(),
+        legacy_request->tx_match_filter_len);
+  legacy_request->rssi_threshold_flag = hidl_request.baseConfigs.useRssiThreshold;
+  legacy_request->recv_indication_cfg = 0;
+  legacy_request->recv_indication_cfg |=
+        hidl_request.baseConfigs.disableDiscoveryTerminationIndication ? 0x1 : 0x0;
+  legacy_request->recv_indication_cfg |=
+        hidl_request.baseConfigs.disableMatchExpirationIndication ? 0x2 : 0x0;
+  legacy_request->recv_indication_cfg |=
+        hidl_request.baseConfigs.disableFollowupReceivedIndication ? 0x4 : 0x0;
+  legacy_request->cipher_type = hidl_request.baseConfigs.supportedCipherTypes;
+  legacy_request->pmk_len = hidl_request.baseConfigs.pmk.size();
+  if (legacy_request->pmk_len > NAN_PMK_INFO_LEN) {
     return false;
   }
+  memcpy(legacy_request->pmk,
+        hidl_request.baseConfigs.pmk.data(),
+        legacy_request->pmk_len);
+  legacy_request->sdea_params.security_cfg = hidl_request.baseConfigs.securityEnabledInNdp ?
+        legacy_hal::NAN_DP_CONFIG_SECURITY : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+  legacy_request->sdea_params.ranging_state = hidl_request.baseConfigs.rangingRequired ?
+        legacy_hal::NAN_RANGING_ENABLE : legacy_hal::NAN_RANGING_DISABLE;
+  legacy_request->ranging_cfg.ranging_interval_msec = hidl_request.baseConfigs.rangingIntervalMsec;
+  legacy_request->ranging_cfg.config_ranging_indications =
+        hidl_request.baseConfigs.configRangingIndications;
+  legacy_request->ranging_cfg.distance_ingress_cm = hidl_request.baseConfigs.distanceIngressCm;
+  legacy_request->ranging_cfg.distance_egress_cm = hidl_request.baseConfigs.distanceEgressCm;
+  legacy_request->subscribe_type = (legacy_hal::NanSubscribeType) hidl_request.subscribeType;
+  legacy_request->serviceResponseFilter = (legacy_hal::NanSRFType) hidl_request.srfType;
+  legacy_request->serviceResponseInclude = hidl_request.srfRespondIfInAddressSet ?
+        legacy_hal::NAN_SRF_INCLUDE_RESPOND : legacy_hal::NAN_SRF_INCLUDE_DO_NOT_RESPOND;
+  legacy_request->useServiceResponseFilter = hidl_request.shouldUseSrf ?
+        legacy_hal::NAN_USE_SRF : legacy_hal::NAN_DO_NOT_USE_SRF;
+  legacy_request->ssiRequiredForMatchIndication = hidl_request.isSsiRequiredForMatch ?
+        legacy_hal::NAN_SSI_REQUIRED_IN_MATCH_IND : legacy_hal::NAN_SSI_NOT_REQUIRED_IN_MATCH_IND;
   legacy_request->num_intf_addr_present = hidl_request.intfAddr.size();
-  for (uint32_t i = 0; i < hidl_request.intfAddr.size(); i++) {
-    CHECK(hidl_request.intfAddr[i].size() ==
-          sizeof(legacy_request->intf_addr[i]));
-    memcpy(legacy_request->intf_addr[i],
-           hidl_request.intfAddr[i].data(),
-           hidl_request.intfAddr[i].size());
-  }
-  legacy_request->recv_indication_cfg = hidl_request.recvIndicationCfg;
-  return true;
-}
+  if (legacy_request->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
+    return false;
+  }
+  for (int i = 0; i < legacy_request->num_intf_addr_present; i++) {
+    memcpy(legacy_request->intf_addr[i], hidl_request.intfAddr[i].data(), 6);
+  }
 
-bool convertHidlNanSubscribeCancelRequestToLegacy(
-    const NanSubscribeCancelRequest& /* hidl_request */,
-    legacy_hal::NanSubscribeCancelRequest* /* legacy_request */) {
-  return false;
+  return true;
 }
 
 bool convertHidlNanTransmitFollowupRequestToLegacy(
-    const NanTransmitFollowupRequest& /* hidl_request */,
-    legacy_hal::NanTransmitFollowupRequest* /* legacy_request */) {
-  return false;
+    const NanTransmitFollowupRequest& hidl_request,
+    legacy_hal::NanTransmitFollowupRequest* legacy_request) {
+  if (!legacy_request) {
+    return false;
+  }
+  memset(&legacy_request, 0, sizeof(legacy_hal::NanTransmitFollowupRequest));
+
+  legacy_request->publish_subscribe_id = hidl_request.discoverySessionId;
+  legacy_request->requestor_instance_id = hidl_request.peerId;
+  memcpy(legacy_request->addr, hidl_request.addr.data(), 6);
+  legacy_request->priority = hidl_request.isHighPriority ?
+        legacy_hal::NAN_TX_PRIORITY_HIGH : legacy_hal::NAN_TX_PRIORITY_NORMAL;
+  legacy_request->dw_or_faw = hidl_request.shouldUseDiscoveryWindow ?
+        legacy_hal::NAN_TRANSMIT_IN_DW : legacy_hal::NAN_TRANSMIT_IN_FAW;
+  legacy_request->service_specific_info_len = hidl_request.message.size();
+  if (legacy_request->service_specific_info_len > NAN_MAX_SERVICE_SPECIFIC_INFO_LEN) {
+    return false;
+  }
+  memcpy(legacy_request->service_specific_info,
+        hidl_request.message.data(),
+        legacy_request->service_specific_info_len);
+  legacy_request->recv_indication_cfg = hidl_request.disableFollowupResultIndication ? 0x1 : 0x0;
+
+  return true;
 }
 
 bool convertHidlNanConfigRequestToLegacy(
-    const NanConfigRequest& /* hidl_request */,
-    legacy_hal::NanConfigRequest* /* legacy_request */) {
-  return false;
+    const NanConfigRequest& hidl_request,
+    legacy_hal::NanConfigRequest* legacy_request) {
+  if (!legacy_request) {
+    return false;
+  }
+  memset(&legacy_request, 0, sizeof(legacy_hal::NanConfigRequest));
+
+  // TODO: b/34059183 tracks missing configurations in legacy HAL or uknown defaults
+  legacy_request->master_pref = hidl_request.masterPref;
+  legacy_request->discovery_indication_cfg = 0;
+  legacy_request->discovery_indication_cfg |=
+        hidl_request.disableDiscoveryAddressChangeIndication ? 0x1 : 0x0;
+  legacy_request->discovery_indication_cfg |=
+        hidl_request.disableStartedClusterIndication ? 0x2 : 0x0;
+  legacy_request->discovery_indication_cfg |=
+        hidl_request.disableJoinedClusterIndication ? 0x4 : 0x0;
+  legacy_request->config_sid_beacon = 1;
+  if (hidl_request.numberOfServiceIdsInBeacon > 127) {
+    return false;
+  }
+  legacy_request->sid_beacon = (hidl_request.includeServiceIdsInBeacon ? 0x1 : 0x0)
+        | (hidl_request.numberOfServiceIdsInBeacon << 1);
+  legacy_request->config_rssi_window_size = 0; // TODO: don't know default yet
+  legacy_request->rssi_window_size_val = hidl_request.rssiWindowSize;
+  legacy_request->config_disc_mac_addr_randomization = 1;
+  legacy_request->disc_mac_addr_rand_interval_sec =
+        hidl_request.macAddressRandomizationIntervalSec;
+  legacy_request->config_responder_auto_response = 1;
+  legacy_request->ranging_auto_response_cfg = hidl_request.acceptRangingRequests ?
+       legacy_hal::NAN_RANGING_AUTO_RESPONSE_ENABLE : legacy_hal::NAN_RANGING_AUTO_RESPONSE_DISABLE;
+  /* TODO : missing
+  legacy_request->config_2dot4g_rssi_close = 0; // TODO: don't know default yet
+  legacy_request->rssi_close_2dot4g_val =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiClose;
+  legacy_request->config_2dot4g_rssi_middle = 0; // TODO: don't know default yet
+  legacy_request->rssi_middle_2dot4g_val =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiMiddle;
+  legacy_request->config_2dot4g_rssi_proximity = 0; // TODO: don't know default yet
+  legacy_request->rssi_proximity_2dot4g_val =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].rssiProximity;
+  */
+  legacy_request->config_scan_params = 0; // TODO: don't know default yet
+  legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_24G_BAND] =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].dwellTimeMs;
+  legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_24G_BAND] =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_24GHZ].scanPeriodSec;
+  legacy_request->config_dw.config_2dot4g_dw_band = hidl_request
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].validDiscoveryWindowIntervalVal;
+  legacy_request->config_dw.dw_2dot4g_interval_val = hidl_request
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_24GHZ].discoveryWindowIntervalVal;
+  /* TODO: missing
+  legacy_request->config_5g_rssi_close = 0; // TODO: don't know default yet
+  legacy_request->rssi_close_5g_val =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiClose;
+  legacy_request->config_5g_rssi_middle = 0; // TODO: don't know default yet
+  legacy_request->rssi_middle_5g_val =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiMiddle;
+  */
+  legacy_request->config_5g_rssi_close_proximity = 0; // TODO: don't know default yet
+  legacy_request->rssi_close_proximity_5g_val =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].rssiProximity;
+  legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
+  legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_LOW] =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
+  legacy_request->scan_params_val.dwell_time[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].dwellTimeMs;
+  legacy_request->scan_params_val.scan_period[legacy_hal::NAN_CHANNEL_5G_BAND_HIGH] =
+        hidl_request.bandSpecificConfig[
+            (size_t) NanBandIndex::NAN_BAND_5GHZ].scanPeriodSec;
+  legacy_request->config_dw.config_5g_dw_band = hidl_request
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].validDiscoveryWindowIntervalVal;
+  legacy_request->config_dw.dw_5g_interval_val = hidl_request
+        .bandSpecificConfig[(size_t) NanBandIndex::NAN_BAND_5GHZ].discoveryWindowIntervalVal;
+
+  return true;
 }
 
 bool convertHidlNanBeaconSdfPayloadRequestToLegacy(
-    const NanBeaconSdfPayloadRequest& /* hidl_request */,
-    legacy_hal::NanBeaconSdfPayloadRequest* /* legacy_request */) {
-  return false;
+    const NanBeaconSdfPayloadRequest& hidl_request,
+    legacy_hal::NanBeaconSdfPayloadRequest* legacy_request) {
+  if (!legacy_request) {
+    return false;
+  }
+  memset(&legacy_request, 0, sizeof(legacy_hal::NanBeaconSdfPayloadRequest));
+
+  legacy_request->vsa.payload_transmit_flag = hidl_request.transmitInNext16dws ? 1 : 0;
+  legacy_request->vsa.tx_in_discovery_beacon = hidl_request.transmitInDiscoveryBeacon;
+  legacy_request->vsa.tx_in_sync_beacon = hidl_request.transmitInSyncBeacon;
+  legacy_request->vsa.tx_in_service_discovery = hidl_request.transmitInServiceDiscoveryFrame;
+  legacy_request->vsa.vendor_oui = hidl_request.vendorOui;
+  legacy_request->vsa.vsa_len = hidl_request.vsa.size();
+  if (legacy_request->vsa.vsa_len > NAN_MAX_VSA_DATA_LEN) {
+    return false;
+  }
+  memcpy(legacy_request->vsa.vsa, hidl_request.vsa.data(), legacy_request->vsa.vsa_len);
+
+  return true;
 }
 
 bool convertHidlNanDataPathInitiatorRequestToLegacy(
-    const NanDataPathInitiatorRequest& /* hidl_request */,
-    legacy_hal::NanDataPathInitiatorRequest* /* legacy_request */) {
-  return false;
+    const NanInitiateDataPathRequest& hidl_request,
+    legacy_hal::NanDataPathInitiatorRequest* legacy_request) {
+  if (!legacy_request) {
+    return false;
+  }
+  memset(&legacy_request, 0, sizeof(legacy_hal::NanDataPathInitiatorRequest));
+
+  legacy_request->requestor_instance_id = hidl_request.peerId;
+  memcpy(legacy_request->peer_disc_mac_addr, hidl_request.peerDiscMacAddr.data(), 6);
+  legacy_request->channel_request_type =
+        (legacy_hal::NanDataPathChannelCfg) hidl_request.channelRequestType;
+  legacy_request->channel = hidl_request.channel;
+  strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
+  legacy_request->ndp_cfg.security_cfg = hidl_request.securityRequired ?
+        legacy_hal::NAN_DP_CONFIG_SECURITY : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+  legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
+  if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
+    return false;
+  }
+  memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
+        legacy_request->app_info.ndp_app_info_len);
+  legacy_request->cipher_type = hidl_request.supportedCipherTypes;
+  legacy_request->pmk_len = hidl_request.pmk.size();
+  if (legacy_request->pmk_len > NAN_PMK_INFO_LEN) {
+    return false;
+  }
+  memcpy(legacy_request->pmk, hidl_request.pmk.data(), legacy_request->pmk_len);
+
+  return true;
 }
 
 bool convertHidlNanDataPathIndicationResponseToLegacy(
-    const NanDataPathIndicationResponse& /* hidl_response */,
-    legacy_hal::NanDataPathIndicationResponse* /* legacy_response */) {
-  return false;
-}
+    const NanRespondToDataPathIndicationRequest& hidl_request,
+    legacy_hal::NanDataPathIndicationResponse* legacy_request) {
+  if (!legacy_request) {
+    return false;
+  }
+  memset(&legacy_request, 0, sizeof(legacy_hal::NanDataPathIndicationResponse));
 
-bool convertHidlNanDataPathEndRequestToLegacy(
-    const NanDataPathEndRequest& /* hidl_request */,
-    legacy_hal::NanDataPathEndRequest* /* legacy_request */) {
-  return false;
+  legacy_request->rsp_code = hidl_request.acceptRequest ?
+        legacy_hal::NAN_DP_REQUEST_ACCEPT : legacy_hal::NAN_DP_REQUEST_REJECT;
+  legacy_request->ndp_instance_id = hidl_request.ndpInstanceId;
+  strcpy(legacy_request->ndp_iface, hidl_request.ifaceName.c_str());
+  legacy_request->ndp_cfg.security_cfg = hidl_request.securityRequired ?
+        legacy_hal::NAN_DP_CONFIG_SECURITY : legacy_hal::NAN_DP_CONFIG_NO_SECURITY;
+  legacy_request->app_info.ndp_app_info_len = hidl_request.appInfo.size();
+  if (legacy_request->app_info.ndp_app_info_len > NAN_DP_MAX_APP_INFO_LEN) {
+    return false;
+  }
+  memcpy(legacy_request->app_info.ndp_app_info, hidl_request.appInfo.data(),
+        legacy_request->app_info.ndp_app_info_len);
+  legacy_request->cipher_type = hidl_request.supportedCipherTypes;
+  legacy_request->pmk_len = hidl_request.pmk.size();
+  if (legacy_request->pmk_len > NAN_PMK_INFO_LEN) {
+    return false;
+  }
+  memcpy(legacy_request->pmk, hidl_request.pmk.data(), legacy_request->pmk_len);
+
+  return true;
 }
 
 bool convertLegacyNanResponseHeaderToHidl(
     const legacy_hal::NanResponseMsg& legacy_response,
-    NanResponseMsgHeader* hidl_response) {
-  if (!hidl_response) {
+    WifiNanStatus* wifiNanStatus) {
+  if (!wifiNanStatus) {
     return false;
   }
-  hidl_response->status =
-      convertLegacyNanStatusTypeToHidl(legacy_response.status);
-  hidl_response->value = legacy_response.value;
-  hidl_response->responseType =
-      convertLegacyNanResponseTypeToHidl(legacy_response.response_type);
-  return true;
-}
-
-bool convertLegacyNanPublishResponseToHidl(
-    const legacy_hal::NanPublishResponse& /* legacy_response */,
-    NanPublishResponse* /* hidl_response */) {
-  return false;
-}
+  wifiNanStatus->status = convertLegacyNanStatusTypeToHidl(legacy_response.status);
+  wifiNanStatus->description = legacy_response.nan_error;
 
-bool convertLegacyNanSubscribeResponseToHidl(
-    const legacy_hal::NanSubscribeResponse& /* legacy_response */,
-    NanSubscribeResponse* /* hidl_response */) {
-  return false;
-}
-
-bool convertLegacyNanDataPathResponseToHidl(
-    const legacy_hal::NanDataPathRequestResponse& /* legacy_response */,
-    NanDataPathResponse* /* hidl_response */) {
-  return false;
+  return true;
 }
 
 bool convertLegacyNanCapabilitiesResponseToHidl(
-    const legacy_hal::NanCapabilities& /* legacy_response */,
-    NanCapabilitiesResponse* /* hidl_response */) {
-  return false;
-}
+    const legacy_hal::NanCapabilities& legacy_response,
+    NanCapabilities* hidl_response) {
+  if (!hidl_response) {
+    return false;
+  }
+  hidl_response->maxConcurrentClusters = legacy_response.max_concurrent_nan_clusters;
+  hidl_response->maxPublishes = legacy_response.max_publishes;
+  hidl_response->maxSubscribes = legacy_response.max_subscribes;
+  hidl_response->maxServiceNameLen = legacy_response.max_service_name_len;
+  hidl_response->maxMatchFilterLen = legacy_response.max_match_filter_len;
+  hidl_response->maxTotalMatchFilterLen = legacy_response.max_total_match_filter_len;
+  hidl_response->maxServiceSpecificInfoLen = legacy_response.max_service_specific_info_len;
+  hidl_response->maxVsaDataLen = legacy_response.max_vsa_data_len;
+  hidl_response->maxNdiInterfaces = legacy_response.max_ndi_interfaces;
+  hidl_response->maxNdpSessions = legacy_response.max_ndp_sessions;
+  hidl_response->maxAppInfoLen = legacy_response.max_app_info_len;
+  hidl_response->maxQueuedTransmitFollowupMsgs = legacy_response.max_queued_transmit_followup_msgs;
+  // TODO: b/34059183 to add to underlying HAL
+  hidl_response->maxSubscribeInterfaceAddresses = NAN_MAX_SUBSCRIBE_MAX_ADDRESS;
+  hidl_response->supportedCipherSuites = legacy_response.cipher_suites_supported;
 
-bool convertLegacyNanPublishTerminatedIndToHidl(
-    const legacy_hal::NanPublishTerminatedInd& /* legacy_ind */,
-    NanPublishTerminatedInd* /* hidl_ind */) {
-  return false;
+  return true;
 }
 
 bool convertLegacyNanMatchIndToHidl(
-    const legacy_hal::NanMatchInd& /* legacy_ind */,
-    NanMatchInd* /* hidl_ind */) {
-  return false;
-}
-
-bool convertLegacyNanMatchExpiredIndToHidl(
-    const legacy_hal::NanMatchExpiredInd& /* legacy_ind */,
-    NanMatchExpiredInd* /* hidl_ind */) {
-  return false;
-}
+    const legacy_hal::NanMatchInd& legacy_ind,
+    NanMatchInd* hidl_ind) {
+  if (!hidl_ind) {
+    return false;
+  }
+  hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
+  hidl_ind->peerId = legacy_ind.requestor_instance_id;
+  hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
+  hidl_ind->serviceSpecificInfo = std::vector<uint8_t>(legacy_ind.service_specific_info,
+        legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
+  hidl_ind->matchFilter = std::vector<uint8_t>(legacy_ind.sdf_match_filter,
+        legacy_ind.sdf_match_filter + legacy_ind.sdf_match_filter_len);
+  hidl_ind->matchOccuredInBeaconFlag = legacy_ind.match_occured_flag == 1;
+  hidl_ind->outOfResourceFlag = legacy_ind.out_of_resource_flag == 1;
+  hidl_ind->rssiValue = legacy_ind.rssi_value;
+  hidl_ind->peerSupportedCipherTypes = legacy_ind.peer_cipher_type;
+  hidl_ind->peerRequiresSecurityEnabledInNdp =
+        legacy_ind.peer_sdea_params.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
+  hidl_ind->peerRequiresRanging =
+        legacy_ind.peer_sdea_params.ranging_state == legacy_hal::NAN_RANGING_ENABLE;
+  hidl_ind->rangingMeasurementInCm = legacy_ind.range_result.range_measurement_cm;
+  hidl_ind->rangingIndicationType = legacy_ind.range_result.ranging_event_type;
 
-bool convertLegacyNanSubscribeTerminatedIndToHidl(
-    const legacy_hal::NanSubscribeTerminatedInd& /* legacy_ind */,
-    NanSubscribeTerminatedInd* /* hidl_ind */) {
-  return false;
+  return true;
 }
 
 bool convertLegacyNanFollowupIndToHidl(
-    const legacy_hal::NanFollowupInd& /* legacy_ind */,
-    NanFollowupInd* /* hidl_ind */) {
-  return false;
-}
-
-bool convertLegacyNanDiscEngEventIndToHidl(
-    const legacy_hal::NanDiscEngEventInd& /* legacy_ind */,
-    NanDiscEngEventInd* /* hidl_ind */) {
-  return false;
-}
+    const legacy_hal::NanFollowupInd& legacy_ind,
+    NanFollowupReceivedInd* hidl_ind) {
+  if (!hidl_ind) {
+    return false;
+  }
+  hidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id;
+  hidl_ind->peerId = legacy_ind.requestor_instance_id;
+  hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
+  hidl_ind->receivedInFaw = legacy_ind.dw_or_faw == 1;
+  hidl_ind->message = std::vector<uint8_t>(legacy_ind.service_specific_info,
+        legacy_ind.service_specific_info + legacy_ind.service_specific_info_len);
 
-bool convertLegacyNanDisabledIndToHidl(
-    const legacy_hal::NanDisabledInd& /* legacy_ind */,
-    NanDisabledInd* /* hidl_ind */) {
-  return false;
+  return true;
 }
 
 bool convertLegacyNanBeaconSdfPayloadIndToHidl(
-    const legacy_hal::NanBeaconSdfPayloadInd& /* legacy_ind */,
-    NanBeaconSdfPayloadInd* /* hidl_ind */) {
-  return false;
+    const legacy_hal::NanBeaconSdfPayloadInd& legacy_ind,
+    NanBeaconSdfPayloadInd* hidl_ind) {
+  if (!hidl_ind) {
+    return false;
+  }
+  hidl_ind->addr = hidl_array<uint8_t, 6>(legacy_ind.addr);
+  hidl_ind->isVsaReceived = legacy_ind.is_vsa_received == 1;
+  hidl_ind->vsaReceivedOnFrames = legacy_ind.vsa.vsa_received_on;
+  hidl_ind->vsaVendorOui = legacy_ind.vsa.vendor_oui;
+  hidl_ind->vsa = std::vector<uint8_t>(legacy_ind.vsa.vsa,
+        legacy_ind.vsa.vsa + legacy_ind.vsa.attr_len);
+  hidl_ind->isBeaconSdfPayloadReceived = legacy_ind.is_beacon_sdf_payload_received == 1;
+  hidl_ind->beaconSdfPayloadData = std::vector<uint8_t>(legacy_ind.data.frame_data,
+        legacy_ind.data.frame_data + legacy_ind.data.frame_len);
+
+  return true;
 }
 
 bool convertLegacyNanDataPathRequestIndToHidl(
-    const legacy_hal::NanDataPathRequestInd& /* legacy_ind */,
-    NanDataPathRequestInd* /* hidl_ind */) {
-  return false;
-}
+    const legacy_hal::NanDataPathRequestInd& legacy_ind,
+    NanDataPathRequestInd* hidl_ind) {
+  if (!hidl_ind) {
+    return false;
+  }
+  hidl_ind->discoverySessionId = legacy_ind.service_instance_id;
+  hidl_ind->peerDiscMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_disc_mac_addr);
+  hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
+  hidl_ind->securityRequired =
+        legacy_ind.ndp_cfg.security_cfg == legacy_hal::NAN_DP_CONFIG_SECURITY;
+  hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
+        legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
 
-bool convertLegacyNanDataPathConfirmIndToHidl(
-    const legacy_hal::NanDataPathConfirmInd& /* legacy_ind */,
-    NanDataPathConfirmInd* /* hidl_ind */) {
-  return false;
+  return true;
 }
 
-bool convertLegacyNanDataPathEndIndToHidl(
-    const legacy_hal::NanDataPathEndInd& /* legacy_ind */,
-    NanDataPathEndInd* /* hidl_ind */) {
-  return false;
-}
+bool convertLegacyNanDataPathConfirmIndToHidl(
+    const legacy_hal::NanDataPathConfirmInd& legacy_ind,
+    NanDataPathConfirmInd* hidl_ind) {
+  if (!hidl_ind) {
+    return false;
+  }
+  hidl_ind->ndpInstanceId = legacy_ind.ndp_instance_id;
+  hidl_ind->dataPathSetupSuccess = legacy_ind.rsp_code == legacy_hal::NAN_DP_REQUEST_ACCEPT;
+  hidl_ind->peerNdiMacAddr = hidl_array<uint8_t, 6>(legacy_ind.peer_ndi_mac_addr);
+  hidl_ind->appInfo = std::vector<uint8_t>(legacy_ind.app_info.ndp_app_info,
+          legacy_ind.app_info.ndp_app_info + legacy_ind.app_info.ndp_app_info_len);
+  hidl_ind->status.status = convertLegacyNanStatusTypeToHidl(legacy_ind.reason_code);
+  hidl_ind->status.description = ""; // TODO: b/34059183
 
-bool convertLegacyNanTransmitFollowupIndToHidl(
-    const legacy_hal::NanTransmitFollowupInd& /* legacy_ind */,
-    NanTransmitFollowupInd* /* hidl_ind */) {
-  return false;
+  return true;
 }
 
 legacy_hal::wifi_rtt_type convertHidlRttTypeToLegacy(RttType type) {