wifi/1.0/default/hidl_struct_util.cpp

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <android-base/logging.h>
#include <utils/SystemClock.h>

#include "hidl_struct_util.h"

namespace android {
namespace hardware {
namespace wifi {
namespace V1_0 {
namespace implementation {
namespace hidl_struct_util {

uint8_t convertHidlScanReportEventFlagToLegacy(
    StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
  using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
  switch (hidl_flag) {
    case HidlFlag::EACH_SCAN:
      return REPORT_EVENTS_EACH_SCAN;
    case HidlFlag::FULL_RESULTS:
      return REPORT_EVENTS_FULL_RESULTS;
    case HidlFlag::NO_BATCH:
      return REPORT_EVENTS_NO_BATCH;
  };
}

StaScanDataFlagMask convertLegacyScanDataFlagToHidl(uint8_t legacy_flag) {
  switch (legacy_flag) {
    case legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED:
      return StaScanDataFlagMask::INTERRUPTED;
  };
  CHECK(false) << "Unknown legacy flag: " << legacy_flag;
  // To silence the compiler warning about reaching the end of non-void
  // function.
  return StaScanDataFlagMask::INTERRUPTED;
}

bool convertHidlScanParamsToLegacy(
    const StaBackgroundScanParameters& hidl_scan_params,
    legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
  if (!legacy_scan_params) {
    return false;
  }
  legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
  legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
  legacy_scan_params->report_threshold_percent =
      hidl_scan_params.reportThresholdPercent;
  legacy_scan_params->report_threshold_num_scans =
      hidl_scan_params.reportThresholdNumScans;
  // TODO(b/33194311): Expose these max limits in the HIDL interface.
  if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
    return false;
  }
  legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
  for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
       bucket_idx++) {
    const StaBackgroundScanBucketParameters& hidl_bucket_spec =
        hidl_scan_params.buckets[bucket_idx];
    legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
        legacy_scan_params->buckets[bucket_idx];
    legacy_bucket_spec.bucket = bucket_idx;
    legacy_bucket_spec.band =
        static_cast<legacy_hal::wifi_band>(hidl_bucket_spec.band);
    legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
    legacy_bucket_spec.max_period = hidl_bucket_spec.exponentialMaxPeriodInMs;
    legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
    legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
    legacy_bucket_spec.report_events = 0;
    using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
    for (const auto flag :
         {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS, HidlFlag::NO_BATCH}) {
      if (hidl_bucket_spec.eventReportScheme &
          static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
        legacy_bucket_spec.report_events |=
            convertHidlScanReportEventFlagToLegacy(flag);
      }
    }
    // TODO(b/33194311): Expose these max limits in the HIDL interface.
    if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
      return false;
    }
    legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
    for (uint32_t freq_idx = 0; freq_idx < hidl_bucket_spec.frequencies.size();
         freq_idx++) {
      legacy_bucket_spec.channels[freq_idx].channel =
          hidl_bucket_spec.frequencies[freq_idx];
    }
  }
  return true;
}

bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob,
                               uint32_t ie_blob_len,
                               std::vector<WifiInformationElement>* hidl_ies) {
  if (!ie_blob || !hidl_ies) {
    return false;
  }
  const uint8_t* ies_begin = ie_blob;
  const uint8_t* ies_end = ie_blob + ie_blob_len;
  const uint8_t* next_ie = ies_begin;
  using wifi_ie = legacy_hal::wifi_information_element;
  constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
  // Each IE should atleast have the header (i.e |id| & |len| fields).
  while (next_ie + kIeHeaderLen <= ies_end) {
    const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
    uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
    if (next_ie + curr_ie_len > ies_end) {
      return false;
    }
    WifiInformationElement hidl_ie;
    hidl_ie.id = legacy_ie.id;
    hidl_ie.data =
        std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
    hidl_ies->push_back(std::move(hidl_ie));
    next_ie += curr_ie_len;
  }
  // Ensure that the blob has been fully consumed.
  return (next_ie == ies_end);
}

bool convertLegacyScanResultToHidl(
    const legacy_hal::wifi_scan_result& legacy_scan_result,
    bool has_ie_data,
    StaScanResult* hidl_scan_result) {
  if (!hidl_scan_result) {
    return false;
  }
  hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
  hidl_scan_result->ssid = std::vector<uint8_t>(
      legacy_scan_result.ssid,
      legacy_scan_result.ssid + sizeof(legacy_scan_result.ssid));
  memcpy(hidl_scan_result->bssid.data(),
         legacy_scan_result.bssid,
         hidl_scan_result->bssid.size());
  hidl_scan_result->frequency = legacy_scan_result.channel;
  hidl_scan_result->rssi = legacy_scan_result.rssi;
  hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
  hidl_scan_result->capability = legacy_scan_result.capability;
  if (has_ie_data) {
    std::vector<WifiInformationElement> ies;
    if (!convertLegacyIeBlobToHidl(
            reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
            legacy_scan_result.ie_length,
            &ies)) {
      return false;
    }
    hidl_scan_result->informationElements = std::move(ies);
  }
  return true;
}

bool convertLegacyCachedScanResultsToHidl(
    const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
    StaScanData* hidl_scan_data) {
  if (!hidl_scan_data) {
    return false;
  }
  for (const auto flag : {legacy_hal::WIFI_SCAN_FLAG_INTERRUPTED}) {
    if (legacy_cached_scan_result.flags & flag) {
      hidl_scan_data->flags |=
          static_cast<std::underlying_type<StaScanDataFlagMask>::type>(
              convertLegacyScanDataFlagToHidl(flag));
    }
  }
  hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;

  CHECK(legacy_cached_scan_result.num_results >= 0 &&
        legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
  std::vector<StaScanResult> hidl_scan_results;
  for (int32_t result_idx = 0;
       result_idx < legacy_cached_scan_result.num_results;
       result_idx++) {
    StaScanResult hidl_scan_result;
    if (!convertLegacyScanResultToHidl(
            legacy_cached_scan_result.results[result_idx],
            false,
            &hidl_scan_result)) {
      return false;
    }
    hidl_scan_results.push_back(hidl_scan_result);
  }
  hidl_scan_data->results = std::move(hidl_scan_results);
  return true;
}

bool convertLegacyVectorOfCachedScanResultsToHidl(
    const std::vector<legacy_hal::wifi_cached_scan_results>&
        legacy_cached_scan_results,
    std::vector<StaScanData>* hidl_scan_datas) {
  if (!hidl_scan_datas) {
    return false;
  }
  for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
    StaScanData hidl_scan_data;
    if (!convertLegacyCachedScanResultsToHidl(legacy_cached_scan_result,
                                              &hidl_scan_data)) {
      return false;
    }
    hidl_scan_datas->push_back(hidl_scan_data);
  }
  return true;
}

WifiDebugTxPacketFate convertLegacyDebugTxPacketFateToHidl(
    legacy_hal::wifi_tx_packet_fate fate) {
  switch (fate) {
    case legacy_hal::TX_PKT_FATE_ACKED:
      return WifiDebugTxPacketFate::ACKED;
    case legacy_hal::TX_PKT_FATE_SENT:
      return WifiDebugTxPacketFate::SENT;
    case legacy_hal::TX_PKT_FATE_FW_QUEUED:
      return WifiDebugTxPacketFate::FW_QUEUED;
    case legacy_hal::TX_PKT_FATE_FW_DROP_INVALID:
      return WifiDebugTxPacketFate::FW_DROP_INVALID;
    case legacy_hal::TX_PKT_FATE_FW_DROP_NOBUFS:
      return WifiDebugTxPacketFate::FW_DROP_NOBUFS;
    case legacy_hal::TX_PKT_FATE_FW_DROP_OTHER:
      return WifiDebugTxPacketFate::FW_DROP_OTHER;
    case legacy_hal::TX_PKT_FATE_DRV_QUEUED:
      return WifiDebugTxPacketFate::DRV_QUEUED;
    case legacy_hal::TX_PKT_FATE_DRV_DROP_INVALID:
      return WifiDebugTxPacketFate::DRV_DROP_INVALID;
    case legacy_hal::TX_PKT_FATE_DRV_DROP_NOBUFS:
      return WifiDebugTxPacketFate::DRV_DROP_NOBUFS;
    case legacy_hal::TX_PKT_FATE_DRV_DROP_OTHER:
      return WifiDebugTxPacketFate::DRV_DROP_OTHER;
  };
}

WifiDebugRxPacketFate convertLegacyDebugRxPacketFateToHidl(
    legacy_hal::wifi_rx_packet_fate fate) {
  switch (fate) {
    case legacy_hal::RX_PKT_FATE_SUCCESS:
      return WifiDebugRxPacketFate::SUCCESS;
    case legacy_hal::RX_PKT_FATE_FW_QUEUED:
      return WifiDebugRxPacketFate::FW_QUEUED;
    case legacy_hal::RX_PKT_FATE_FW_DROP_FILTER:
      return WifiDebugRxPacketFate::FW_DROP_FILTER;
    case legacy_hal::RX_PKT_FATE_FW_DROP_INVALID:
      return WifiDebugRxPacketFate::FW_DROP_INVALID;
    case legacy_hal::RX_PKT_FATE_FW_DROP_NOBUFS:
      return WifiDebugRxPacketFate::FW_DROP_NOBUFS;
    case legacy_hal::RX_PKT_FATE_FW_DROP_OTHER:
      return WifiDebugRxPacketFate::FW_DROP_OTHER;
    case legacy_hal::RX_PKT_FATE_DRV_QUEUED:
      return WifiDebugRxPacketFate::DRV_QUEUED;
    case legacy_hal::RX_PKT_FATE_DRV_DROP_FILTER:
      return WifiDebugRxPacketFate::DRV_DROP_FILTER;
    case legacy_hal::RX_PKT_FATE_DRV_DROP_INVALID:
      return WifiDebugRxPacketFate::DRV_DROP_INVALID;
    case legacy_hal::RX_PKT_FATE_DRV_DROP_NOBUFS:
      return WifiDebugRxPacketFate::DRV_DROP_NOBUFS;
    case legacy_hal::RX_PKT_FATE_DRV_DROP_OTHER:
      return WifiDebugRxPacketFate::DRV_DROP_OTHER;
  };
}

WifiDebugPacketFateFrameType convertLegacyDebugPacketFateFrameTypeToHidl(
    legacy_hal::frame_type type) {
  switch (type) {
    case legacy_hal::FRAME_TYPE_UNKNOWN:
      return WifiDebugPacketFateFrameType::UNKNOWN;
    case legacy_hal::FRAME_TYPE_ETHERNET_II:
      return WifiDebugPacketFateFrameType::ETHERNET_II;
    case legacy_hal::FRAME_TYPE_80211_MGMT:
      return WifiDebugPacketFateFrameType::MGMT_80211;
  };
}

bool convertLegacyDebugPacketFateFrameToHidl(
    const legacy_hal::frame_info& legacy_frame,
    WifiDebugPacketFateFrameInfo* hidl_frame) {
  if (!hidl_frame) {
    return false;
  }
  hidl_frame->frameType =
      convertLegacyDebugPacketFateFrameTypeToHidl(legacy_frame.payload_type);
  hidl_frame->frameLen = legacy_frame.frame_len;
  hidl_frame->driverTimestampUsec = legacy_frame.driver_timestamp_usec;
  hidl_frame->firmwareTimestampUsec = legacy_frame.firmware_timestamp_usec;
  const uint8_t* frame_begin = reinterpret_cast<const uint8_t*>(
      legacy_frame.frame_content.ethernet_ii_bytes);
  hidl_frame->frameContent =
      std::vector<uint8_t>(frame_begin, frame_begin + legacy_frame.frame_len);
  return true;
}

bool convertLegacyDebugTxPacketFateToHidl(
    const legacy_hal::wifi_tx_report& legacy_fate,
    WifiDebugTxPacketFateReport* hidl_fate) {
  if (!hidl_fate) {
    return false;
  }
  hidl_fate->fate = convertLegacyDebugTxPacketFateToHidl(legacy_fate.fate);
  return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
                                                 &hidl_fate->frameInfo);
}

bool convertLegacyDebugRxPacketFateToHidl(
    const legacy_hal::wifi_rx_report& legacy_fate,
    WifiDebugRxPacketFateReport* hidl_fate) {
  if (!hidl_fate) {
    return false;
  }
  hidl_fate->fate = convertLegacyDebugRxPacketFateToHidl(legacy_fate.fate);
  return convertLegacyDebugPacketFateFrameToHidl(legacy_fate.frame_inf,
                                                 &hidl_fate->frameInfo);
}

bool convertLegacyLinkLayerStatsToHidl(
    const legacy_hal::LinkLayerStats& legacy_stats,
    StaLinkLayerStats* hidl_stats) {
  if (!hidl_stats) {
    return false;
  }
  // iface legacy_stats conversion.
  hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
  hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
  hidl_stats->iface.wmeBePktStats.rxMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
  hidl_stats->iface.wmeBePktStats.txMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
  hidl_stats->iface.wmeBePktStats.lostMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
  hidl_stats->iface.wmeBePktStats.retries =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
  hidl_stats->iface.wmeBkPktStats.rxMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
  hidl_stats->iface.wmeBkPktStats.txMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
  hidl_stats->iface.wmeBkPktStats.lostMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
  hidl_stats->iface.wmeBkPktStats.retries =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
  hidl_stats->iface.wmeViPktStats.rxMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
  hidl_stats->iface.wmeViPktStats.txMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
  hidl_stats->iface.wmeViPktStats.lostMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
  hidl_stats->iface.wmeViPktStats.retries =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
  hidl_stats->iface.wmeVoPktStats.rxMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
  hidl_stats->iface.wmeVoPktStats.txMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
  hidl_stats->iface.wmeVoPktStats.lostMpdu =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
  hidl_stats->iface.wmeVoPktStats.retries =
      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
  // radio legacy_stats conversion.
  hidl_stats->radio.onTimeInMs = legacy_stats.radio.on_time;
  hidl_stats->radio.txTimeInMs = legacy_stats.radio.tx_time;
  hidl_stats->radio.rxTimeInMs = legacy_stats.radio.rx_time;
  hidl_stats->radio.onTimeInMsForScan = legacy_stats.radio.on_time_scan;
  hidl_stats->radio.txTimeInMsPerLevel = legacy_stats.radio_tx_time_per_levels;
  // Timestamp in the HAL wrapper here since it's not provided in the legacy
  // HAL API.
  hidl_stats->timeStampInMs = uptimeMillis();
  return true;
}

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;
  };
}

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;
  };
}

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;
  };
}

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;
  };
}

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;
  };
}

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;
  };
}

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;
  };
}

bool convertHidlNanEnableRequestToLegacy(
    const NanEnableRequest& hidl_request,
    legacy_hal::NanEnableRequest* legacy_request) {
  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;
  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;
  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;
  return true;
}

bool convertHidlNanPublishRequestToLegacy(
    const NanPublishRequest& hidl_request,
    legacy_hal::NanPublishRequest* legacy_request) {
  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)) {
    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());
  legacy_request->publish_match_indicator =
      convertHidlNanMatchAlgToLegacy(hidl_request.publishMatchIndicator);
  if (hidl_request.serviceSpecificInfo.size() >
      sizeof(legacy_request->service_specific_info)) {
    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)) {
    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)) {
    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;
}

bool convertHidlNanPublishCancelRequestToLegacy(
    const NanPublishCancelRequest& hidl_request,
    legacy_hal::NanPublishCancelRequest* legacy_request) {
  legacy_request->publish_id = hidl_request.publishId;
  return true;
}

bool convertHidlNanSubscribeRequestToLegacy(
    const NanSubscribeRequest& hidl_request,
    legacy_hal::NanSubscribeRequest* legacy_request) {
  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)) {
    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)) {
    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)) {
    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)) {
    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) {
    return false;
  }
  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;
}

bool convertHidlNanSubscribeCancelRequestToLegacy(
    const NanSubscribeCancelRequest& /* hidl_request */,
    legacy_hal::NanSubscribeCancelRequest* /* legacy_request */) {
  return false;
}

bool convertHidlNanTransmitFollowupRequestToLegacy(
    const NanTransmitFollowupRequest& /* hidl_request */,
    legacy_hal::NanTransmitFollowupRequest* /* legacy_request */) {
  return false;
}

bool convertHidlNanConfigRequestToLegacy(
    const NanConfigRequest& /* hidl_request */,
    legacy_hal::NanConfigRequest* /* legacy_request */) {
  return false;
}

bool convertHidlNanBeaconSdfPayloadRequestToLegacy(
    const NanBeaconSdfPayloadRequest& /* hidl_request */,
    legacy_hal::NanBeaconSdfPayloadRequest* /* legacy_request */) {
  return false;
}

bool convertHidlNanDataPathInitiatorRequestToLegacy(
    const NanDataPathInitiatorRequest& /* hidl_request */,
    legacy_hal::NanDataPathInitiatorRequest* /* legacy_request */) {
  return false;
}

bool convertHidlNanDataPathIndicationResponseToLegacy(
    const NanDataPathIndicationResponse& /* hidl_response */,
    legacy_hal::NanDataPathIndicationResponse* /* legacy_response */) {
  return false;
}

bool convertHidlNanDataPathEndRequestToLegacy(
    const NanDataPathEndRequest& /* hidl_request */,
    legacy_hal::NanDataPathEndRequest* /* legacy_request */) {
  return false;
}

bool convertLegacyNanResponseHeaderToHidl(
    const legacy_hal::NanResponseMsg& legacy_response,
    NanResponseMsgHeader* hidl_response) {
  if (!hidl_response) {
    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;
}

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;
}

bool convertLegacyNanCapabilitiesResponseToHidl(
    const legacy_hal::NanCapabilities& /* legacy_response */,
    NanCapabilitiesResponse* /* hidl_response */) {
  return false;
}

bool convertLegacyNanPublishTerminatedIndToHidl(
    const legacy_hal::NanPublishTerminatedInd& /* legacy_ind */,
    NanPublishTerminatedInd* /* hidl_ind */) {
  return false;
}

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;
}

bool convertLegacyNanSubscribeTerminatedIndToHidl(
    const legacy_hal::NanSubscribeTerminatedInd& /* legacy_ind */,
    NanSubscribeTerminatedInd* /* hidl_ind */) {
  return false;
}

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;
}

bool convertLegacyNanDisabledIndToHidl(
    const legacy_hal::NanDisabledInd& /* legacy_ind */,
    NanDisabledInd* /* hidl_ind */) {
  return false;
}

bool convertLegacyNanBeaconSdfPayloadIndToHidl(
    const legacy_hal::NanBeaconSdfPayloadInd& /* legacy_ind */,
    NanBeaconSdfPayloadInd* /* hidl_ind */) {
  return false;
}

bool convertLegacyNanDataPathRequestIndToHidl(
    const legacy_hal::NanDataPathRequestInd& /* legacy_ind */,
    NanDataPathRequestInd* /* hidl_ind */) {
  return false;
}

bool convertLegacyNanDataPathConfirmIndToHidl(
    const legacy_hal::NanDataPathConfirmInd& /* legacy_ind */,
    NanDataPathConfirmInd* /* hidl_ind */) {
  return false;
}

bool convertLegacyNanDataPathEndIndToHidl(
    const legacy_hal::NanDataPathEndInd& /* legacy_ind */,
    NanDataPathEndInd* /* hidl_ind */) {
  return false;
}

bool convertLegacyNanTransmitFollowupIndToHidl(
    const legacy_hal::NanTransmitFollowupInd& /* legacy_ind */,
    NanTransmitFollowupInd* /* hidl_ind */) {
  return false;
}
}  // namespace hidl_struct_util
}  // namespace implementation
}  // namespace V1_0
}  // namespace wifi
}  // namespace hardware
}  // namespace android