wifi/1.2/default/wifi_legacy_hal.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 <array>
  18 #include <chrono>
  19
  20 #include <android-base/logging.h>
  21
  22 #include "hidl_sync_util.h"
  23 #include "wifi_legacy_hal.h"
  24 #include "wifi_legacy_hal_stubs.h"
  25
  26 namespace {
  27 // Constants ported over from the legacy HAL calling code
  28 // (com_android_server_wifi_WifiNative.cpp). This will all be thrown
  29 // away when this shim layer is replaced by the real vendor
  30 // implementation.
  31 static constexpr uint32_t kMaxVersionStringLength = 256;
  32 static constexpr uint32_t kMaxCachedGscanResults = 64;
  33 static constexpr uint32_t kMaxGscanFrequenciesForBand = 64;
  34 static constexpr uint32_t kLinkLayerStatsDataMpduSizeThreshold = 128;
  35 static constexpr uint32_t kMaxWakeReasonStatsArraySize = 32;
  36 static constexpr uint32_t kMaxRingBuffers = 10;
  37 static constexpr uint32_t kMaxStopCompleteWaitMs = 100;
  38
  39 // Helper function to create a non-const char* for legacy Hal API's.
  40 std::vector<char> makeCharVec(const std::string& str) {
  41     std::vector<char> vec(str.size() + 1);
  42     vec.assign(str.begin(), str.end());
  43     vec.push_back('\0');
  44     return vec;
  45 }
  46 }  // namespace
  47
  48 namespace android {
  49 namespace hardware {
  50 namespace wifi {
  51 namespace V1_2 {
  52 namespace implementation {
  53 namespace legacy_hal {
  54 // Legacy HAL functions accept "C" style function pointers, so use global
  55 // functions to pass to the legacy HAL function and store the corresponding
  56 // std::function methods to be invoked.
  57 //
  58 // Callback to be invoked once |stop| is complete
  59 std::function<void(wifi_handle handle)> on_stop_complete_internal_callback;
  60 void onAsyncStopComplete(wifi_handle handle) {
  61     const auto lock = hidl_sync_util::acquireGlobalLock();
  62     if (on_stop_complete_internal_callback) {
  63         on_stop_complete_internal_callback(handle);
  64         // Invalidate this callback since we don't want this firing again.
  65         on_stop_complete_internal_callback = nullptr;
  66     }
  67 }
  68
  69 // Callback to be invoked for driver dump.
  70 std::function<void(char*, int)> on_driver_memory_dump_internal_callback;
  71 void onSyncDriverMemoryDump(char* buffer, int buffer_size) {
  72     if (on_driver_memory_dump_internal_callback) {
  73         on_driver_memory_dump_internal_callback(buffer, buffer_size);
  74     }
  75 }
  76
  77 // Callback to be invoked for firmware dump.
  78 std::function<void(char*, int)> on_firmware_memory_dump_internal_callback;
  79 void onSyncFirmwareMemoryDump(char* buffer, int buffer_size) {
  80     if (on_firmware_memory_dump_internal_callback) {
  81         on_firmware_memory_dump_internal_callback(buffer, buffer_size);
  82     }
  83 }
  84
  85 // Callback to be invoked for Gscan events.
  86 std::function<void(wifi_request_id, wifi_scan_event)>
  87     on_gscan_event_internal_callback;
  88 void onAsyncGscanEvent(wifi_request_id id, wifi_scan_event event) {
  89     const auto lock = hidl_sync_util::acquireGlobalLock();
  90     if (on_gscan_event_internal_callback) {
  91         on_gscan_event_internal_callback(id, event);
  92     }
  93 }
  94
  95 // Callback to be invoked for Gscan full results.
  96 std::function<void(wifi_request_id, wifi_scan_result*, uint32_t)>
  97     on_gscan_full_result_internal_callback;
  98 void onAsyncGscanFullResult(wifi_request_id id, wifi_scan_result* result,
  99                             uint32_t buckets_scanned) {
 100     const auto lock = hidl_sync_util::acquireGlobalLock();
 101     if (on_gscan_full_result_internal_callback) {
 102         on_gscan_full_result_internal_callback(id, result, buckets_scanned);
 103     }
 104 }
 105
 106 // Callback to be invoked for link layer stats results.
 107 std::function<void((wifi_request_id, wifi_iface_stat*, int, wifi_radio_stat*))>
 108     on_link_layer_stats_result_internal_callback;
 109 void onSyncLinkLayerStatsResult(wifi_request_id id, wifi_iface_stat* iface_stat,
 110                                 int num_radios, wifi_radio_stat* radio_stat) {
 111     if (on_link_layer_stats_result_internal_callback) {
 112         on_link_layer_stats_result_internal_callback(id, iface_stat, num_radios,
 113                                                      radio_stat);
 114     }
 115 }
 116
 117 // Callback to be invoked for rssi threshold breach.
 118 std::function<void((wifi_request_id, uint8_t*, int8_t))>
 119     on_rssi_threshold_breached_internal_callback;
 120 void onAsyncRssiThresholdBreached(wifi_request_id id, uint8_t* bssid,
 121                                   int8_t rssi) {
 122     const auto lock = hidl_sync_util::acquireGlobalLock();
 123     if (on_rssi_threshold_breached_internal_callback) {
 124         on_rssi_threshold_breached_internal_callback(id, bssid, rssi);
 125     }
 126 }
 127
 128 // Callback to be invoked for ring buffer data indication.
 129 std::function<void(char*, char*, int, wifi_ring_buffer_status*)>
 130     on_ring_buffer_data_internal_callback;
 131 void onAsyncRingBufferData(char* ring_name, char* buffer, int buffer_size,
 132                            wifi_ring_buffer_status* status) {
 133     const auto lock = hidl_sync_util::acquireGlobalLock();
 134     if (on_ring_buffer_data_internal_callback) {
 135         on_ring_buffer_data_internal_callback(ring_name, buffer, buffer_size,
 136                                               status);
 137     }
 138 }
 139
 140 // Callback to be invoked for error alert indication.
 141 std::function<void(wifi_request_id, char*, int, int)>
 142     on_error_alert_internal_callback;
 143 void onAsyncErrorAlert(wifi_request_id id, char* buffer, int buffer_size,
 144                        int err_code) {
 145     const auto lock = hidl_sync_util::acquireGlobalLock();
 146     if (on_error_alert_internal_callback) {
 147         on_error_alert_internal_callback(id, buffer, buffer_size, err_code);
 148     }
 149 }
 150
 151 // Callback to be invoked for radio mode change indication.
 152 std::function<void(wifi_request_id, uint32_t, wifi_mac_info*)>
 153     on_radio_mode_change_internal_callback;
 154 void onAsyncRadioModeChange(wifi_request_id id, uint32_t num_macs,
 155                             wifi_mac_info* mac_infos) {
 156     const auto lock = hidl_sync_util::acquireGlobalLock();
 157     if (on_radio_mode_change_internal_callback) {
 158         on_radio_mode_change_internal_callback(id, num_macs, mac_infos);
 159     }
 160 }
 161
 162 // Callback to be invoked for rtt results results.
 163 std::function<void(wifi_request_id, unsigned num_results,
 164                    wifi_rtt_result* rtt_results[])>
 165     on_rtt_results_internal_callback;
 166 void onAsyncRttResults(wifi_request_id id, unsigned num_results,
 167                        wifi_rtt_result* rtt_results[]) {
 168     const auto lock = hidl_sync_util::acquireGlobalLock();
 169     if (on_rtt_results_internal_callback) {
 170         on_rtt_results_internal_callback(id, num_results, rtt_results);
 171         on_rtt_results_internal_callback = nullptr;
 172     }
 173 }
 174
 175 // Callbacks for the various NAN operations.
 176 // NOTE: These have very little conversions to perform before invoking the user
 177 // callbacks.
 178 // So, handle all of them here directly to avoid adding an unnecessary layer.
 179 std::function<void(transaction_id, const NanResponseMsg&)>
 180     on_nan_notify_response_user_callback;
 181 void onAysncNanNotifyResponse(transaction_id id, NanResponseMsg* msg) {
 182     const auto lock = hidl_sync_util::acquireGlobalLock();
 183     if (on_nan_notify_response_user_callback && msg) {
 184         on_nan_notify_response_user_callback(id, *msg);
 185     }
 186 }
 187
 188 std::function<void(const NanPublishRepliedInd&)>
 189     on_nan_event_publish_replied_user_callback;
 190 void onAysncNanEventPublishReplied(NanPublishRepliedInd* /* event */) {
 191     LOG(ERROR) << "onAysncNanEventPublishReplied triggered";
 192 }
 193
 194 std::function<void(const NanPublishTerminatedInd&)>
 195     on_nan_event_publish_terminated_user_callback;
 196 void onAysncNanEventPublishTerminated(NanPublishTerminatedInd* event) {
 197     const auto lock = hidl_sync_util::acquireGlobalLock();
 198     if (on_nan_event_publish_terminated_user_callback && event) {
 199         on_nan_event_publish_terminated_user_callback(*event);
 200     }
 201 }
 202
 203 std::function<void(const NanMatchInd&)> on_nan_event_match_user_callback;
 204 void onAysncNanEventMatch(NanMatchInd* event) {
 205     const auto lock = hidl_sync_util::acquireGlobalLock();
 206     if (on_nan_event_match_user_callback && event) {
 207         on_nan_event_match_user_callback(*event);
 208     }
 209 }
 210
 211 std::function<void(const NanMatchExpiredInd&)>
 212     on_nan_event_match_expired_user_callback;
 213 void onAysncNanEventMatchExpired(NanMatchExpiredInd* event) {
 214     const auto lock = hidl_sync_util::acquireGlobalLock();
 215     if (on_nan_event_match_expired_user_callback && event) {
 216         on_nan_event_match_expired_user_callback(*event);
 217     }
 218 }
 219
 220 std::function<void(const NanSubscribeTerminatedInd&)>
 221     on_nan_event_subscribe_terminated_user_callback;
 222 void onAysncNanEventSubscribeTerminated(NanSubscribeTerminatedInd* event) {
 223     const auto lock = hidl_sync_util::acquireGlobalLock();
 224     if (on_nan_event_subscribe_terminated_user_callback && event) {
 225         on_nan_event_subscribe_terminated_user_callback(*event);
 226     }
 227 }
 228
 229 std::function<void(const NanFollowupInd&)> on_nan_event_followup_user_callback;
 230 void onAysncNanEventFollowup(NanFollowupInd* event) {
 231     const auto lock = hidl_sync_util::acquireGlobalLock();
 232     if (on_nan_event_followup_user_callback && event) {
 233         on_nan_event_followup_user_callback(*event);
 234     }
 235 }
 236
 237 std::function<void(const NanDiscEngEventInd&)>
 238     on_nan_event_disc_eng_event_user_callback;
 239 void onAysncNanEventDiscEngEvent(NanDiscEngEventInd* event) {
 240     const auto lock = hidl_sync_util::acquireGlobalLock();
 241     if (on_nan_event_disc_eng_event_user_callback && event) {
 242         on_nan_event_disc_eng_event_user_callback(*event);
 243     }
 244 }
 245
 246 std::function<void(const NanDisabledInd&)> on_nan_event_disabled_user_callback;
 247 void onAysncNanEventDisabled(NanDisabledInd* event) {
 248     const auto lock = hidl_sync_util::acquireGlobalLock();
 249     if (on_nan_event_disabled_user_callback && event) {
 250         on_nan_event_disabled_user_callback(*event);
 251     }
 252 }
 253
 254 std::function<void(const NanTCAInd&)> on_nan_event_tca_user_callback;
 255 void onAysncNanEventTca(NanTCAInd* event) {
 256     const auto lock = hidl_sync_util::acquireGlobalLock();
 257     if (on_nan_event_tca_user_callback && event) {
 258         on_nan_event_tca_user_callback(*event);
 259     }
 260 }
 261
 262 std::function<void(const NanBeaconSdfPayloadInd&)>
 263     on_nan_event_beacon_sdf_payload_user_callback;
 264 void onAysncNanEventBeaconSdfPayload(NanBeaconSdfPayloadInd* event) {
 265     const auto lock = hidl_sync_util::acquireGlobalLock();
 266     if (on_nan_event_beacon_sdf_payload_user_callback && event) {
 267         on_nan_event_beacon_sdf_payload_user_callback(*event);
 268     }
 269 }
 270
 271 std::function<void(const NanDataPathRequestInd&)>
 272     on_nan_event_data_path_request_user_callback;
 273 void onAysncNanEventDataPathRequest(NanDataPathRequestInd* event) {
 274     const auto lock = hidl_sync_util::acquireGlobalLock();
 275     if (on_nan_event_data_path_request_user_callback && event) {
 276         on_nan_event_data_path_request_user_callback(*event);
 277     }
 278 }
 279 std::function<void(const NanDataPathConfirmInd&)>
 280     on_nan_event_data_path_confirm_user_callback;
 281 void onAysncNanEventDataPathConfirm(NanDataPathConfirmInd* event) {
 282     const auto lock = hidl_sync_util::acquireGlobalLock();
 283     if (on_nan_event_data_path_confirm_user_callback && event) {
 284         on_nan_event_data_path_confirm_user_callback(*event);
 285     }
 286 }
 287
 288 std::function<void(const NanDataPathEndInd&)>
 289     on_nan_event_data_path_end_user_callback;
 290 void onAysncNanEventDataPathEnd(NanDataPathEndInd* event) {
 291     const auto lock = hidl_sync_util::acquireGlobalLock();
 292     if (on_nan_event_data_path_end_user_callback && event) {
 293         on_nan_event_data_path_end_user_callback(*event);
 294     }
 295 }
 296
 297 std::function<void(const NanTransmitFollowupInd&)>
 298     on_nan_event_transmit_follow_up_user_callback;
 299 void onAysncNanEventTransmitFollowUp(NanTransmitFollowupInd* event) {
 300     const auto lock = hidl_sync_util::acquireGlobalLock();
 301     if (on_nan_event_transmit_follow_up_user_callback && event) {
 302         on_nan_event_transmit_follow_up_user_callback(*event);
 303     }
 304 }
 305
 306 std::function<void(const NanRangeRequestInd&)>
 307     on_nan_event_range_request_user_callback;
 308 void onAysncNanEventRangeRequest(NanRangeRequestInd* event) {
 309     const auto lock = hidl_sync_util::acquireGlobalLock();
 310     if (on_nan_event_range_request_user_callback && event) {
 311         on_nan_event_range_request_user_callback(*event);
 312     }
 313 }
 314
 315 std::function<void(const NanRangeReportInd&)>
 316     on_nan_event_range_report_user_callback;
 317 void onAysncNanEventRangeReport(NanRangeReportInd* event) {
 318     const auto lock = hidl_sync_util::acquireGlobalLock();
 319     if (on_nan_event_range_report_user_callback && event) {
 320         on_nan_event_range_report_user_callback(*event);
 321     }
 322 }
 323
 324 std::function<void(const NanDataPathScheduleUpdateInd&)>
 325     on_nan_event_schedule_update_user_callback;
 326 void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) {
 327     const auto lock = hidl_sync_util::acquireGlobalLock();
 328     if (on_nan_event_schedule_update_user_callback && event) {
 329         on_nan_event_schedule_update_user_callback(*event);
 330     }
 331 }
 332 // End of the free-standing "C" style callbacks.
 333
 334 WifiLegacyHal::WifiLegacyHal()
 335     : global_handle_(nullptr),
 336       awaiting_event_loop_termination_(false),
 337       is_started_(false) {}
 338
 339 wifi_error WifiLegacyHal::initialize() {
 340     LOG(DEBUG) << "Initialize legacy HAL";
 341     // TODO: Add back the HAL Tool if we need to. All we need from the HAL tool
 342     // for now is this function call which we can directly call.
 343     if (!initHalFuncTableWithStubs(&global_func_table_)) {
 344         LOG(ERROR)
 345             << "Failed to initialize legacy hal function table with stubs";
 346         return WIFI_ERROR_UNKNOWN;
 347     }
 348     wifi_error status = init_wifi_vendor_hal_func_table(&global_func_table_);
 349     if (status != WIFI_SUCCESS) {
 350         LOG(ERROR) << "Failed to initialize legacy hal function table";
 351     }
 352     return status;
 353 }
 354
 355 wifi_error WifiLegacyHal::start() {
 356     // Ensure that we're starting in a good state.
 357     CHECK(global_func_table_.wifi_initialize && !global_handle_ &&
 358           iface_name_to_handle_.empty() && !awaiting_event_loop_termination_);
 359     if (is_started_) {
 360         LOG(DEBUG) << "Legacy HAL already started";
 361         return WIFI_SUCCESS;
 362     }
 363     LOG(DEBUG) << "Waiting for the driver ready";
 364     wifi_error status = global_func_table_.wifi_wait_for_driver_ready();
 365     if (status == WIFI_ERROR_TIMED_OUT) {
 366         LOG(ERROR) << "Timed out awaiting driver ready";
 367         return status;
 368     }
 369     LOG(DEBUG) << "Starting legacy HAL";
 370     if (!iface_tool_.SetWifiUpState(true)) {
 371         LOG(ERROR) << "Failed to set WiFi interface up";
 372         return WIFI_ERROR_UNKNOWN;
 373     }
 374     status = global_func_table_.wifi_initialize(&global_handle_);
 375     if (status != WIFI_SUCCESS || !global_handle_) {
 376         LOG(ERROR) << "Failed to retrieve global handle";
 377         return status;
 378     }
 379     std::thread(&WifiLegacyHal::runEventLoop, this).detach();
 380     status = retrieveIfaceHandles();
 381     if (status != WIFI_SUCCESS || iface_name_to_handle_.empty()) {
 382         LOG(ERROR) << "Failed to retrieve wlan interface handle";
 383         return status;
 384     }
 385     LOG(DEBUG) << "Legacy HAL start complete";
 386     is_started_ = true;
 387     return WIFI_SUCCESS;
 388 }
 389
 390 wifi_error WifiLegacyHal::stop(
 391     /* NONNULL */ std::unique_lock<std::recursive_mutex>* lock,
 392     const std::function<void()>& on_stop_complete_user_callback) {
 393     if (!is_started_) {
 394         LOG(DEBUG) << "Legacy HAL already stopped";
 395         on_stop_complete_user_callback();
 396         return WIFI_SUCCESS;
 397     }
 398     LOG(DEBUG) << "Stopping legacy HAL";
 399     on_stop_complete_internal_callback = [on_stop_complete_user_callback,
 400                                           this](wifi_handle handle) {
 401         CHECK_EQ(global_handle_, handle) << "Handle mismatch";
 402         LOG(INFO) << "Legacy HAL stop complete callback received";
 403         // Invalidate all the internal pointers now that the HAL is
 404         // stopped.
 405         invalidate();
 406         iface_tool_.SetWifiUpState(false);
 407         on_stop_complete_user_callback();
 408         is_started_ = false;
 409     };
 410     awaiting_event_loop_termination_ = true;
 411     global_func_table_.wifi_cleanup(global_handle_, onAsyncStopComplete);
 412     const auto status = stop_wait_cv_.wait_for(
 413         *lock, std::chrono::milliseconds(kMaxStopCompleteWaitMs),
 414         [this] { return !awaiting_event_loop_termination_; });
 415     if (!status) {
 416         LOG(ERROR) << "Legacy HAL stop failed or timed out";
 417         return WIFI_ERROR_UNKNOWN;
 418     }
 419     LOG(DEBUG) << "Legacy HAL stop complete";
 420     return WIFI_SUCCESS;
 421 }
 422
 423 std::pair<wifi_error, std::string> WifiLegacyHal::getDriverVersion(
 424     const std::string& iface_name) {
 425     std::array<char, kMaxVersionStringLength> buffer;
 426     buffer.fill(0);
 427     wifi_error status = global_func_table_.wifi_get_driver_version(
 428         getIfaceHandle(iface_name), buffer.data(), buffer.size());
 429     return {status, buffer.data()};
 430 }
 431
 432 std::pair<wifi_error, std::string> WifiLegacyHal::getFirmwareVersion(
 433     const std::string& iface_name) {
 434     std::array<char, kMaxVersionStringLength> buffer;
 435     buffer.fill(0);
 436     wifi_error status = global_func_table_.wifi_get_firmware_version(
 437         getIfaceHandle(iface_name), buffer.data(), buffer.size());
 438     return {status, buffer.data()};
 439 }
 440
 441 std::pair<wifi_error, std::vector<uint8_t>>
 442 WifiLegacyHal::requestDriverMemoryDump(const std::string& iface_name) {
 443     std::vector<uint8_t> driver_dump;
 444     on_driver_memory_dump_internal_callback = [&driver_dump](char* buffer,
 445                                                              int buffer_size) {
 446         driver_dump.insert(driver_dump.end(),
 447                            reinterpret_cast<uint8_t*>(buffer),
 448                            reinterpret_cast<uint8_t*>(buffer) + buffer_size);
 449     };
 450     wifi_error status = global_func_table_.wifi_get_driver_memory_dump(
 451         getIfaceHandle(iface_name), {onSyncDriverMemoryDump});
 452     on_driver_memory_dump_internal_callback = nullptr;
 453     return {status, std::move(driver_dump)};
 454 }
 455
 456 std::pair<wifi_error, std::vector<uint8_t>>
 457 WifiLegacyHal::requestFirmwareMemoryDump(const std::string& iface_name) {
 458     std::vector<uint8_t> firmware_dump;
 459     on_firmware_memory_dump_internal_callback =
 460         [&firmware_dump](char* buffer, int buffer_size) {
 461             firmware_dump.insert(
 462                 firmware_dump.end(), reinterpret_cast<uint8_t*>(buffer),
 463                 reinterpret_cast<uint8_t*>(buffer) + buffer_size);
 464         };
 465     wifi_error status = global_func_table_.wifi_get_firmware_memory_dump(
 466         getIfaceHandle(iface_name), {onSyncFirmwareMemoryDump});
 467     on_firmware_memory_dump_internal_callback = nullptr;
 468     return {status, std::move(firmware_dump)};
 469 }
 470
 471 std::pair<wifi_error, uint32_t> WifiLegacyHal::getSupportedFeatureSet(
 472     const std::string& iface_name) {
 473     feature_set set;
 474     static_assert(sizeof(set) == sizeof(uint32_t),
 475                   "Some feature_flags can not be represented in output");
 476     wifi_error status = global_func_table_.wifi_get_supported_feature_set(
 477         getIfaceHandle(iface_name), &set);
 478     return {status, static_cast<uint32_t>(set)};
 479 }
 480
 481 std::pair<wifi_error, PacketFilterCapabilities>
 482 WifiLegacyHal::getPacketFilterCapabilities(const std::string& iface_name) {
 483     PacketFilterCapabilities caps;
 484     wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
 485         getIfaceHandle(iface_name), &caps.version, &caps.max_len);
 486     return {status, caps};
 487 }
 488
 489 wifi_error WifiLegacyHal::setPacketFilter(const std::string& iface_name,
 490                                           const std::vector<uint8_t>& program) {
 491     return global_func_table_.wifi_set_packet_filter(
 492         getIfaceHandle(iface_name), program.data(), program.size());
 493 }
 494
 495 std::pair<wifi_error, std::vector<uint8_t>>
 496 WifiLegacyHal::readApfPacketFilterData(const std::string& iface_name) {
 497     PacketFilterCapabilities caps;
 498     wifi_error status = global_func_table_.wifi_get_packet_filter_capabilities(
 499         getIfaceHandle(iface_name), &caps.version, &caps.max_len);
 500     if (status != WIFI_SUCCESS) {
 501         return {status, {}};
 502     }
 503
 504     // Size the buffer to read the entire program & work memory.
 505     std::vector<uint8_t> buffer(caps.max_len);
 506
 507     status = global_func_table_.wifi_read_packet_filter(
 508         getIfaceHandle(iface_name), /*src_offset=*/0, buffer.data(),
 509         buffer.size());
 510     return {status, move(buffer)};
 511 }
 512
 513 std::pair<wifi_error, wifi_gscan_capabilities>
 514 WifiLegacyHal::getGscanCapabilities(const std::string& iface_name) {
 515     wifi_gscan_capabilities caps;
 516     wifi_error status = global_func_table_.wifi_get_gscan_capabilities(
 517         getIfaceHandle(iface_name), &caps);
 518     return {status, caps};
 519 }
 520
 521 wifi_error WifiLegacyHal::startGscan(
 522     const std::string& iface_name, wifi_request_id id,
 523     const wifi_scan_cmd_params& params,
 524     const std::function<void(wifi_request_id)>& on_failure_user_callback,
 525     const on_gscan_results_callback& on_results_user_callback,
 526     const on_gscan_full_result_callback& on_full_result_user_callback) {
 527     // If there is already an ongoing background scan, reject new scan requests.
 528     if (on_gscan_event_internal_callback ||
 529         on_gscan_full_result_internal_callback) {
 530         return WIFI_ERROR_NOT_AVAILABLE;
 531     }
 532
 533     // This callback will be used to either trigger |on_results_user_callback|
 534     // or |on_failure_user_callback|.
 535     on_gscan_event_internal_callback =
 536         [iface_name, on_failure_user_callback, on_results_user_callback, this](
 537             wifi_request_id id, wifi_scan_event event) {
 538             switch (event) {
 539                 case WIFI_SCAN_RESULTS_AVAILABLE:
 540                 case WIFI_SCAN_THRESHOLD_NUM_SCANS:
 541                 case WIFI_SCAN_THRESHOLD_PERCENT: {
 542                     wifi_error status;
 543                     std::vector<wifi_cached_scan_results> cached_scan_results;
 544                     std::tie(status, cached_scan_results) =
 545                         getGscanCachedResults(iface_name);
 546                     if (status == WIFI_SUCCESS) {
 547                         on_results_user_callback(id, cached_scan_results);
 548                         return;
 549                     }
 550                 }
 551                 // Fall through if failed. Failure to retrieve cached scan
 552                 // results should trigger a background scan failure.
 553                 case WIFI_SCAN_FAILED:
 554                     on_failure_user_callback(id);
 555                     on_gscan_event_internal_callback = nullptr;
 556                     on_gscan_full_result_internal_callback = nullptr;
 557                     return;
 558             }
 559             LOG(FATAL) << "Unexpected gscan event received: " << event;
 560         };
 561
 562     on_gscan_full_result_internal_callback = [on_full_result_user_callback](
 563                                                  wifi_request_id id,
 564                                                  wifi_scan_result* result,
 565                                                  uint32_t buckets_scanned) {
 566         if (result) {
 567             on_full_result_user_callback(id, result, buckets_scanned);
 568         }
 569     };
 570
 571     wifi_scan_result_handler handler = {onAsyncGscanFullResult,
 572                                         onAsyncGscanEvent};
 573     wifi_error status = global_func_table_.wifi_start_gscan(
 574         id, getIfaceHandle(iface_name), params, handler);
 575     if (status != WIFI_SUCCESS) {
 576         on_gscan_event_internal_callback = nullptr;
 577         on_gscan_full_result_internal_callback = nullptr;
 578     }
 579     return status;
 580 }
 581
 582 wifi_error WifiLegacyHal::stopGscan(const std::string& iface_name,
 583                                     wifi_request_id id) {
 584     // If there is no an ongoing background scan, reject stop requests.
 585     // TODO(b/32337212): This needs to be handled by the HIDL object because we
 586     // need to return the NOT_STARTED error code.
 587     if (!on_gscan_event_internal_callback &&
 588         !on_gscan_full_result_internal_callback) {
 589         return WIFI_ERROR_NOT_AVAILABLE;
 590     }
 591     wifi_error status =
 592         global_func_table_.wifi_stop_gscan(id, getIfaceHandle(iface_name));
 593     // If the request Id is wrong, don't stop the ongoing background scan. Any
 594     // other error should be treated as the end of background scan.
 595     if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
 596         on_gscan_event_internal_callback = nullptr;
 597         on_gscan_full_result_internal_callback = nullptr;
 598     }
 599     return status;
 600 }
 601
 602 std::pair<wifi_error, std::vector<uint32_t>>
 603 WifiLegacyHal::getValidFrequenciesForBand(const std::string& iface_name,
 604                                           wifi_band band) {
 605     static_assert(sizeof(uint32_t) >= sizeof(wifi_channel),
 606                   "Wifi Channel cannot be represented in output");
 607     std::vector<uint32_t> freqs;
 608     freqs.resize(kMaxGscanFrequenciesForBand);
 609     int32_t num_freqs = 0;
 610     wifi_error status = global_func_table_.wifi_get_valid_channels(
 611         getIfaceHandle(iface_name), band, freqs.size(),
 612         reinterpret_cast<wifi_channel*>(freqs.data()), &num_freqs);
 613     CHECK(num_freqs >= 0 &&
 614           static_cast<uint32_t>(num_freqs) <= kMaxGscanFrequenciesForBand);
 615     freqs.resize(num_freqs);
 616     return {status, std::move(freqs)};
 617 }
 618
 619 wifi_error WifiLegacyHal::setDfsFlag(const std::string& iface_name,
 620                                      bool dfs_on) {
 621     return global_func_table_.wifi_set_nodfs_flag(getIfaceHandle(iface_name),
 622                                                   dfs_on ? 0 : 1);
 623 }
 624
 625 wifi_error WifiLegacyHal::enableLinkLayerStats(const std::string& iface_name,
 626                                                bool debug) {
 627     wifi_link_layer_params params;
 628     params.mpdu_size_threshold = kLinkLayerStatsDataMpduSizeThreshold;
 629     params.aggressive_statistics_gathering = debug;
 630     return global_func_table_.wifi_set_link_stats(getIfaceHandle(iface_name),
 631                                                   params);
 632 }
 633
 634 wifi_error WifiLegacyHal::disableLinkLayerStats(const std::string& iface_name) {
 635     // TODO: Do we care about these responses?
 636     uint32_t clear_mask_rsp;
 637     uint8_t stop_rsp;
 638     return global_func_table_.wifi_clear_link_stats(
 639         getIfaceHandle(iface_name), 0xFFFFFFFF, &clear_mask_rsp, 1, &stop_rsp);
 640 }
 641
 642 std::pair<wifi_error, LinkLayerStats> WifiLegacyHal::getLinkLayerStats(
 643     const std::string& iface_name) {
 644     LinkLayerStats link_stats{};
 645     LinkLayerStats* link_stats_ptr = &link_stats;
 646
 647     on_link_layer_stats_result_internal_callback =
 648         [&link_stats_ptr](wifi_request_id /* id */,
 649                           wifi_iface_stat* iface_stats_ptr, int num_radios,
 650                           wifi_radio_stat* radio_stats_ptr) {
 651             if (iface_stats_ptr != nullptr) {
 652                 link_stats_ptr->iface = *iface_stats_ptr;
 653                 link_stats_ptr->iface.num_peers = 0;
 654             } else {
 655                 LOG(ERROR) << "Invalid iface stats in link layer stats";
 656             }
 657             if (num_radios <= 0 || radio_stats_ptr == nullptr) {
 658                 LOG(ERROR) << "Invalid radio stats in link layer stats";
 659                 return;
 660             }
 661             for (int i = 0; i < num_radios; i++) {
 662                 LinkLayerRadioStats radio;
 663                 radio.stats = radio_stats_ptr[i];
 664                 // Copy over the tx level array to the separate vector.
 665                 if (radio_stats_ptr[i].num_tx_levels > 0 &&
 666                     radio_stats_ptr[i].tx_time_per_levels != nullptr) {
 667                     radio.tx_time_per_levels.assign(
 668                         radio_stats_ptr[i].tx_time_per_levels,
 669                         radio_stats_ptr[i].tx_time_per_levels +
 670                             radio_stats_ptr[i].num_tx_levels);
 671                 }
 672                 radio.stats.num_tx_levels = 0;
 673                 radio.stats.tx_time_per_levels = nullptr;
 674                 link_stats_ptr->radios.push_back(radio);
 675             }
 676         };
 677
 678     wifi_error status = global_func_table_.wifi_get_link_stats(
 679         0, getIfaceHandle(iface_name), {onSyncLinkLayerStatsResult});
 680     on_link_layer_stats_result_internal_callback = nullptr;
 681     return {status, link_stats};
 682 }
 683
 684 wifi_error WifiLegacyHal::startRssiMonitoring(
 685     const std::string& iface_name, wifi_request_id id, int8_t max_rssi,
 686     int8_t min_rssi,
 687     const on_rssi_threshold_breached_callback&
 688         on_threshold_breached_user_callback) {
 689     if (on_rssi_threshold_breached_internal_callback) {
 690         return WIFI_ERROR_NOT_AVAILABLE;
 691     }
 692     on_rssi_threshold_breached_internal_callback =
 693         [on_threshold_breached_user_callback](wifi_request_id id,
 694                                               uint8_t* bssid_ptr, int8_t rssi) {
 695             if (!bssid_ptr) {
 696                 return;
 697             }
 698             std::array<uint8_t, 6> bssid_arr;
 699             // |bssid_ptr| pointer is assumed to have 6 bytes for the mac
 700             // address.
 701             std::copy(bssid_ptr, bssid_ptr + 6, std::begin(bssid_arr));
 702             on_threshold_breached_user_callback(id, bssid_arr, rssi);
 703         };
 704     wifi_error status = global_func_table_.wifi_start_rssi_monitoring(
 705         id, getIfaceHandle(iface_name), max_rssi, min_rssi,
 706         {onAsyncRssiThresholdBreached});
 707     if (status != WIFI_SUCCESS) {
 708         on_rssi_threshold_breached_internal_callback = nullptr;
 709     }
 710     return status;
 711 }
 712
 713 wifi_error WifiLegacyHal::stopRssiMonitoring(const std::string& iface_name,
 714                                              wifi_request_id id) {
 715     if (!on_rssi_threshold_breached_internal_callback) {
 716         return WIFI_ERROR_NOT_AVAILABLE;
 717     }
 718     wifi_error status = global_func_table_.wifi_stop_rssi_monitoring(
 719         id, getIfaceHandle(iface_name));
 720     // If the request Id is wrong, don't stop the ongoing rssi monitoring. Any
 721     // other error should be treated as the end of background scan.
 722     if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
 723         on_rssi_threshold_breached_internal_callback = nullptr;
 724     }
 725     return status;
 726 }
 727
 728 std::pair<wifi_error, wifi_roaming_capabilities>
 729 WifiLegacyHal::getRoamingCapabilities(const std::string& iface_name) {
 730     wifi_roaming_capabilities caps;
 731     wifi_error status = global_func_table_.wifi_get_roaming_capabilities(
 732         getIfaceHandle(iface_name), &caps);
 733     return {status, caps};
 734 }
 735
 736 wifi_error WifiLegacyHal::configureRoaming(const std::string& iface_name,
 737                                            const wifi_roaming_config& config) {
 738     wifi_roaming_config config_internal = config;
 739     return global_func_table_.wifi_configure_roaming(getIfaceHandle(iface_name),
 740                                                      &config_internal);
 741 }
 742
 743 wifi_error WifiLegacyHal::enableFirmwareRoaming(const std::string& iface_name,
 744                                                 fw_roaming_state_t state) {
 745     return global_func_table_.wifi_enable_firmware_roaming(
 746         getIfaceHandle(iface_name), state);
 747 }
 748
 749 wifi_error WifiLegacyHal::configureNdOffload(const std::string& iface_name,
 750                                              bool enable) {
 751     return global_func_table_.wifi_configure_nd_offload(
 752         getIfaceHandle(iface_name), enable);
 753 }
 754
 755 wifi_error WifiLegacyHal::startSendingOffloadedPacket(
 756     const std::string& iface_name, uint32_t cmd_id,
 757     const std::vector<uint8_t>& ip_packet_data,
 758     const std::array<uint8_t, 6>& src_address,
 759     const std::array<uint8_t, 6>& dst_address, uint32_t period_in_ms) {
 760     std::vector<uint8_t> ip_packet_data_internal(ip_packet_data);
 761     std::vector<uint8_t> src_address_internal(
 762         src_address.data(), src_address.data() + src_address.size());
 763     std::vector<uint8_t> dst_address_internal(
 764         dst_address.data(), dst_address.data() + dst_address.size());
 765     return global_func_table_.wifi_start_sending_offloaded_packet(
 766         cmd_id, getIfaceHandle(iface_name), ip_packet_data_internal.data(),
 767         ip_packet_data_internal.size(), src_address_internal.data(),
 768         dst_address_internal.data(), period_in_ms);
 769 }
 770
 771 wifi_error WifiLegacyHal::stopSendingOffloadedPacket(
 772     const std::string& iface_name, uint32_t cmd_id) {
 773     return global_func_table_.wifi_stop_sending_offloaded_packet(
 774         cmd_id, getIfaceHandle(iface_name));
 775 }
 776
 777 wifi_error WifiLegacyHal::setScanningMacOui(const std::string& iface_name,
 778                                             const std::array<uint8_t, 3>& oui) {
 779     std::vector<uint8_t> oui_internal(oui.data(), oui.data() + oui.size());
 780     return global_func_table_.wifi_set_scanning_mac_oui(
 781         getIfaceHandle(iface_name), oui_internal.data());
 782 }
 783
 784 wifi_error WifiLegacyHal::selectTxPowerScenario(const std::string& iface_name,
 785                                                 wifi_power_scenario scenario) {
 786     return global_func_table_.wifi_select_tx_power_scenario(
 787         getIfaceHandle(iface_name), scenario);
 788 }
 789
 790 wifi_error WifiLegacyHal::resetTxPowerScenario(const std::string& iface_name) {
 791     return global_func_table_.wifi_reset_tx_power_scenario(
 792         getIfaceHandle(iface_name));
 793 }
 794
 795 std::pair<wifi_error, uint32_t> WifiLegacyHal::getLoggerSupportedFeatureSet(
 796     const std::string& iface_name) {
 797     uint32_t supported_feature_flags;
 798     wifi_error status =
 799         global_func_table_.wifi_get_logger_supported_feature_set(
 800             getIfaceHandle(iface_name), &supported_feature_flags);
 801     return {status, supported_feature_flags};
 802 }
 803
 804 wifi_error WifiLegacyHal::startPktFateMonitoring(
 805     const std::string& iface_name) {
 806     return global_func_table_.wifi_start_pkt_fate_monitoring(
 807         getIfaceHandle(iface_name));
 808 }
 809
 810 std::pair<wifi_error, std::vector<wifi_tx_report>> WifiLegacyHal::getTxPktFates(
 811     const std::string& iface_name) {
 812     std::vector<wifi_tx_report> tx_pkt_fates;
 813     tx_pkt_fates.resize(MAX_FATE_LOG_LEN);
 814     size_t num_fates = 0;
 815     wifi_error status = global_func_table_.wifi_get_tx_pkt_fates(
 816         getIfaceHandle(iface_name), tx_pkt_fates.data(), tx_pkt_fates.size(),
 817         &num_fates);
 818     CHECK(num_fates <= MAX_FATE_LOG_LEN);
 819     tx_pkt_fates.resize(num_fates);
 820     return {status, std::move(tx_pkt_fates)};
 821 }
 822
 823 std::pair<wifi_error, std::vector<wifi_rx_report>> WifiLegacyHal::getRxPktFates(
 824     const std::string& iface_name) {
 825     std::vector<wifi_rx_report> rx_pkt_fates;
 826     rx_pkt_fates.resize(MAX_FATE_LOG_LEN);
 827     size_t num_fates = 0;
 828     wifi_error status = global_func_table_.wifi_get_rx_pkt_fates(
 829         getIfaceHandle(iface_name), rx_pkt_fates.data(), rx_pkt_fates.size(),
 830         &num_fates);
 831     CHECK(num_fates <= MAX_FATE_LOG_LEN);
 832     rx_pkt_fates.resize(num_fates);
 833     return {status, std::move(rx_pkt_fates)};
 834 }
 835
 836 std::pair<wifi_error, WakeReasonStats> WifiLegacyHal::getWakeReasonStats(
 837     const std::string& iface_name) {
 838     WakeReasonStats stats;
 839     stats.cmd_event_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
 840     stats.driver_fw_local_wake_cnt.resize(kMaxWakeReasonStatsArraySize);
 841
 842     // This legacy struct needs separate memory to store the variable sized wake
 843     // reason types.
 844     stats.wake_reason_cnt.cmd_event_wake_cnt =
 845         reinterpret_cast<int32_t*>(stats.cmd_event_wake_cnt.data());
 846     stats.wake_reason_cnt.cmd_event_wake_cnt_sz =
 847         stats.cmd_event_wake_cnt.size();
 848     stats.wake_reason_cnt.cmd_event_wake_cnt_used = 0;
 849     stats.wake_reason_cnt.driver_fw_local_wake_cnt =
 850         reinterpret_cast<int32_t*>(stats.driver_fw_local_wake_cnt.data());
 851     stats.wake_reason_cnt.driver_fw_local_wake_cnt_sz =
 852         stats.driver_fw_local_wake_cnt.size();
 853     stats.wake_reason_cnt.driver_fw_local_wake_cnt_used = 0;
 854
 855     wifi_error status = global_func_table_.wifi_get_wake_reason_stats(
 856         getIfaceHandle(iface_name), &stats.wake_reason_cnt);
 857
 858     CHECK(
 859         stats.wake_reason_cnt.cmd_event_wake_cnt_used >= 0 &&
 860         static_cast<uint32_t>(stats.wake_reason_cnt.cmd_event_wake_cnt_used) <=
 861             kMaxWakeReasonStatsArraySize);
 862     stats.cmd_event_wake_cnt.resize(
 863         stats.wake_reason_cnt.cmd_event_wake_cnt_used);
 864     stats.wake_reason_cnt.cmd_event_wake_cnt = nullptr;
 865
 866     CHECK(stats.wake_reason_cnt.driver_fw_local_wake_cnt_used >= 0 &&
 867           static_cast<uint32_t>(
 868               stats.wake_reason_cnt.driver_fw_local_wake_cnt_used) <=
 869               kMaxWakeReasonStatsArraySize);
 870     stats.driver_fw_local_wake_cnt.resize(
 871         stats.wake_reason_cnt.driver_fw_local_wake_cnt_used);
 872     stats.wake_reason_cnt.driver_fw_local_wake_cnt = nullptr;
 873
 874     return {status, stats};
 875 }
 876
 877 wifi_error WifiLegacyHal::registerRingBufferCallbackHandler(
 878     const std::string& iface_name,
 879     const on_ring_buffer_data_callback& on_user_data_callback) {
 880     if (on_ring_buffer_data_internal_callback) {
 881         return WIFI_ERROR_NOT_AVAILABLE;
 882     }
 883     on_ring_buffer_data_internal_callback =
 884         [on_user_data_callback](char* ring_name, char* buffer, int buffer_size,
 885                                 wifi_ring_buffer_status* status) {
 886             if (status && buffer) {
 887                 std::vector<uint8_t> buffer_vector(
 888                     reinterpret_cast<uint8_t*>(buffer),
 889                     reinterpret_cast<uint8_t*>(buffer) + buffer_size);
 890                 on_user_data_callback(ring_name, buffer_vector, *status);
 891             }
 892         };
 893     wifi_error status = global_func_table_.wifi_set_log_handler(
 894         0, getIfaceHandle(iface_name), {onAsyncRingBufferData});
 895     if (status != WIFI_SUCCESS) {
 896         on_ring_buffer_data_internal_callback = nullptr;
 897     }
 898     return status;
 899 }
 900
 901 wifi_error WifiLegacyHal::deregisterRingBufferCallbackHandler(
 902     const std::string& iface_name) {
 903     if (!on_ring_buffer_data_internal_callback) {
 904         return WIFI_ERROR_NOT_AVAILABLE;
 905     }
 906     on_ring_buffer_data_internal_callback = nullptr;
 907     return global_func_table_.wifi_reset_log_handler(
 908         0, getIfaceHandle(iface_name));
 909 }
 910
 911 std::pair<wifi_error, std::vector<wifi_ring_buffer_status>>
 912 WifiLegacyHal::getRingBuffersStatus(const std::string& iface_name) {
 913     std::vector<wifi_ring_buffer_status> ring_buffers_status;
 914     ring_buffers_status.resize(kMaxRingBuffers);
 915     uint32_t num_rings = kMaxRingBuffers;
 916     wifi_error status = global_func_table_.wifi_get_ring_buffers_status(
 917         getIfaceHandle(iface_name), &num_rings, ring_buffers_status.data());
 918     CHECK(num_rings <= kMaxRingBuffers);
 919     ring_buffers_status.resize(num_rings);
 920     return {status, std::move(ring_buffers_status)};
 921 }
 922
 923 wifi_error WifiLegacyHal::startRingBufferLogging(const std::string& iface_name,
 924                                                  const std::string& ring_name,
 925                                                  uint32_t verbose_level,
 926                                                  uint32_t max_interval_sec,
 927                                                  uint32_t min_data_size) {
 928     return global_func_table_.wifi_start_logging(
 929         getIfaceHandle(iface_name), verbose_level, 0, max_interval_sec,
 930         min_data_size, makeCharVec(ring_name).data());
 931 }
 932
 933 wifi_error WifiLegacyHal::getRingBufferData(const std::string& iface_name,
 934                                             const std::string& ring_name) {
 935     return global_func_table_.wifi_get_ring_data(getIfaceHandle(iface_name),
 936                                                  makeCharVec(ring_name).data());
 937 }
 938
 939 wifi_error WifiLegacyHal::registerErrorAlertCallbackHandler(
 940     const std::string& iface_name,
 941     const on_error_alert_callback& on_user_alert_callback) {
 942     if (on_error_alert_internal_callback) {
 943         return WIFI_ERROR_NOT_AVAILABLE;
 944     }
 945     on_error_alert_internal_callback = [on_user_alert_callback](
 946                                            wifi_request_id id, char* buffer,
 947                                            int buffer_size, int err_code) {
 948         if (buffer) {
 949             CHECK(id == 0);
 950             on_user_alert_callback(
 951                 err_code,
 952                 std::vector<uint8_t>(
 953                     reinterpret_cast<uint8_t*>(buffer),
 954                     reinterpret_cast<uint8_t*>(buffer) + buffer_size));
 955         }
 956     };
 957     wifi_error status = global_func_table_.wifi_set_alert_handler(
 958         0, getIfaceHandle(iface_name), {onAsyncErrorAlert});
 959     if (status != WIFI_SUCCESS) {
 960         on_error_alert_internal_callback = nullptr;
 961     }
 962     return status;
 963 }
 964
 965 wifi_error WifiLegacyHal::deregisterErrorAlertCallbackHandler(
 966     const std::string& iface_name) {
 967     if (!on_error_alert_internal_callback) {
 968         return WIFI_ERROR_NOT_AVAILABLE;
 969     }
 970     on_error_alert_internal_callback = nullptr;
 971     return global_func_table_.wifi_reset_alert_handler(
 972         0, getIfaceHandle(iface_name));
 973 }
 974
 975 wifi_error WifiLegacyHal::registerRadioModeChangeCallbackHandler(
 976     const std::string& iface_name,
 977     const on_radio_mode_change_callback& on_user_change_callback) {
 978     if (on_radio_mode_change_internal_callback) {
 979         return WIFI_ERROR_NOT_AVAILABLE;
 980     }
 981     on_radio_mode_change_internal_callback = [on_user_change_callback](
 982                                                  wifi_request_id /* id */,
 983                                                  uint32_t num_macs,
 984                                                  wifi_mac_info* mac_infos_arr) {
 985         if (num_macs > 0 && mac_infos_arr) {
 986             std::vector<WifiMacInfo> mac_infos_vec;
 987             for (uint32_t i = 0; i < num_macs; i++) {
 988                 WifiMacInfo mac_info;
 989                 mac_info.wlan_mac_id = mac_infos_arr[i].wlan_mac_id;
 990                 mac_info.mac_band = mac_infos_arr[i].mac_band;
 991                 for (int32_t j = 0; j < mac_infos_arr[i].num_iface; j++) {
 992                     WifiIfaceInfo iface_info;
 993                     iface_info.name = mac_infos_arr[i].iface_info[j].iface_name;
 994                     iface_info.channel = mac_infos_arr[i].iface_info[j].channel;
 995                     mac_info.iface_infos.push_back(iface_info);
 996                 }
 997                 mac_infos_vec.push_back(mac_info);
 998             }
 999             on_user_change_callback(mac_infos_vec);
1000         }
1001     };
1002     wifi_error status = global_func_table_.wifi_set_radio_mode_change_handler(
1003         0, getIfaceHandle(iface_name), {onAsyncRadioModeChange});
1004     if (status != WIFI_SUCCESS) {
1005         on_radio_mode_change_internal_callback = nullptr;
1006     }
1007     return status;
1008 }
1009
1010 wifi_error WifiLegacyHal::startRttRangeRequest(
1011     const std::string& iface_name, wifi_request_id id,
1012     const std::vector<wifi_rtt_config>& rtt_configs,
1013     const on_rtt_results_callback& on_results_user_callback) {
1014     if (on_rtt_results_internal_callback) {
1015         return WIFI_ERROR_NOT_AVAILABLE;
1016     }
1017
1018     on_rtt_results_internal_callback =
1019         [on_results_user_callback](wifi_request_id id, unsigned num_results,
1020                                    wifi_rtt_result* rtt_results[]) {
1021             if (num_results > 0 && !rtt_results) {
1022                 LOG(ERROR) << "Unexpected nullptr in RTT results";
1023                 return;
1024             }
1025             std::vector<const wifi_rtt_result*> rtt_results_vec;
1026             std::copy_if(rtt_results, rtt_results + num_results,
1027                          back_inserter(rtt_results_vec),
1028                          [](wifi_rtt_result* rtt_result) {
1029                              return rtt_result != nullptr;
1030                          });
1031             on_results_user_callback(id, rtt_results_vec);
1032         };
1033
1034     std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);
1035     wifi_error status = global_func_table_.wifi_rtt_range_request(
1036         id, getIfaceHandle(iface_name), rtt_configs.size(),
1037         rtt_configs_internal.data(), {onAsyncRttResults});
1038     if (status != WIFI_SUCCESS) {
1039         on_rtt_results_internal_callback = nullptr;
1040     }
1041     return status;
1042 }
1043
1044 wifi_error WifiLegacyHal::cancelRttRangeRequest(
1045     const std::string& iface_name, wifi_request_id id,
1046     const std::vector<std::array<uint8_t, 6>>& mac_addrs) {
1047     if (!on_rtt_results_internal_callback) {
1048         return WIFI_ERROR_NOT_AVAILABLE;
1049     }
1050     static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),
1051                   "MAC address size mismatch");
1052     // TODO: How do we handle partial cancels (i.e only a subset of enabled mac
1053     // addressed are cancelled).
1054     std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);
1055     wifi_error status = global_func_table_.wifi_rtt_range_cancel(
1056         id, getIfaceHandle(iface_name), mac_addrs.size(),
1057         reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));
1058     // If the request Id is wrong, don't stop the ongoing range request. Any
1059     // other error should be treated as the end of rtt ranging.
1060     if (status != WIFI_ERROR_INVALID_REQUEST_ID) {
1061         on_rtt_results_internal_callback = nullptr;
1062     }
1063     return status;
1064 }
1065
1066 std::pair<wifi_error, wifi_rtt_capabilities> WifiLegacyHal::getRttCapabilities(
1067     const std::string& iface_name) {
1068     wifi_rtt_capabilities rtt_caps;
1069     wifi_error status = global_func_table_.wifi_get_rtt_capabilities(
1070         getIfaceHandle(iface_name), &rtt_caps);
1071     return {status, rtt_caps};
1072 }
1073
1074 std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
1075     const std::string& iface_name) {
1076     wifi_rtt_responder rtt_responder;
1077     wifi_error status = global_func_table_.wifi_rtt_get_responder_info(
1078         getIfaceHandle(iface_name), &rtt_responder);
1079     return {status, rtt_responder};
1080 }
1081
1082 wifi_error WifiLegacyHal::enableRttResponder(
1083     const std::string& iface_name, wifi_request_id id,
1084     const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
1085     const wifi_rtt_responder& info) {
1086     wifi_rtt_responder info_internal(info);
1087     return global_func_table_.wifi_enable_responder(
1088         id, getIfaceHandle(iface_name), channel_hint, max_duration_secs,
1089         &info_internal);
1090 }
1091
1092 wifi_error WifiLegacyHal::disableRttResponder(const std::string& iface_name,
1093                                               wifi_request_id id) {
1094     return global_func_table_.wifi_disable_responder(
1095         id, getIfaceHandle(iface_name));
1096 }
1097
1098 wifi_error WifiLegacyHal::setRttLci(const std::string& iface_name,
1099                                     wifi_request_id id,
1100                                     const wifi_lci_information& info) {
1101     wifi_lci_information info_internal(info);
1102     return global_func_table_.wifi_set_lci(id, getIfaceHandle(iface_name),
1103                                            &info_internal);
1104 }
1105
1106 wifi_error WifiLegacyHal::setRttLcr(const std::string& iface_name,
1107                                     wifi_request_id id,
1108                                     const wifi_lcr_information& info) {
1109     wifi_lcr_information info_internal(info);
1110     return global_func_table_.wifi_set_lcr(id, getIfaceHandle(iface_name),
1111                                            &info_internal);
1112 }
1113
1114 wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(
1115     const std::string& iface_name, const NanCallbackHandlers& user_callbacks) {
1116     on_nan_notify_response_user_callback = user_callbacks.on_notify_response;
1117     on_nan_event_publish_terminated_user_callback =
1118         user_callbacks.on_event_publish_terminated;
1119     on_nan_event_match_user_callback = user_callbacks.on_event_match;
1120     on_nan_event_match_expired_user_callback =
1121         user_callbacks.on_event_match_expired;
1122     on_nan_event_subscribe_terminated_user_callback =
1123         user_callbacks.on_event_subscribe_terminated;
1124     on_nan_event_followup_user_callback = user_callbacks.on_event_followup;
1125     on_nan_event_disc_eng_event_user_callback =
1126         user_callbacks.on_event_disc_eng_event;
1127     on_nan_event_disabled_user_callback = user_callbacks.on_event_disabled;
1128     on_nan_event_tca_user_callback = user_callbacks.on_event_tca;
1129     on_nan_event_beacon_sdf_payload_user_callback =
1130         user_callbacks.on_event_beacon_sdf_payload;
1131     on_nan_event_data_path_request_user_callback =
1132         user_callbacks.on_event_data_path_request;
1133     on_nan_event_data_path_confirm_user_callback =
1134         user_callbacks.on_event_data_path_confirm;
1135     on_nan_event_data_path_end_user_callback =
1136         user_callbacks.on_event_data_path_end;
1137     on_nan_event_transmit_follow_up_user_callback =
1138         user_callbacks.on_event_transmit_follow_up;
1139     on_nan_event_range_request_user_callback =
1140         user_callbacks.on_event_range_request;
1141     on_nan_event_range_report_user_callback =
1142         user_callbacks.on_event_range_report;
1143     on_nan_event_schedule_update_user_callback =
1144         user_callbacks.on_event_schedule_update;
1145
1146     return global_func_table_.wifi_nan_register_handler(
1147         getIfaceHandle(iface_name),
1148         {onAysncNanNotifyResponse, onAysncNanEventPublishReplied,
1149          onAysncNanEventPublishTerminated, onAysncNanEventMatch,
1150          onAysncNanEventMatchExpired, onAysncNanEventSubscribeTerminated,
1151          onAysncNanEventFollowup, onAysncNanEventDiscEngEvent,
1152          onAysncNanEventDisabled, onAysncNanEventTca,
1153          onAysncNanEventBeaconSdfPayload, onAysncNanEventDataPathRequest,
1154          onAysncNanEventDataPathConfirm, onAysncNanEventDataPathEnd,
1155          onAysncNanEventTransmitFollowUp, onAysncNanEventRangeRequest,
1156          onAysncNanEventRangeReport, onAsyncNanEventScheduleUpdate});
1157 }
1158
1159 wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name,
1160                                            transaction_id id,
1161                                            const NanEnableRequest& msg) {
1162     NanEnableRequest msg_internal(msg);
1163     return global_func_table_.wifi_nan_enable_request(
1164         id, getIfaceHandle(iface_name), &msg_internal);
1165 }
1166
1167 wifi_error WifiLegacyHal::nanDisableRequest(const std::string& iface_name,
1168                                             transaction_id id) {
1169     return global_func_table_.wifi_nan_disable_request(
1170         id, getIfaceHandle(iface_name));
1171 }
1172
1173 wifi_error WifiLegacyHal::nanPublishRequest(const std::string& iface_name,
1174                                             transaction_id id,
1175                                             const NanPublishRequest& msg) {
1176     NanPublishRequest msg_internal(msg);
1177     return global_func_table_.wifi_nan_publish_request(
1178         id, getIfaceHandle(iface_name), &msg_internal);
1179 }
1180
1181 wifi_error WifiLegacyHal::nanPublishCancelRequest(
1182     const std::string& iface_name, transaction_id id,
1183     const NanPublishCancelRequest& msg) {
1184     NanPublishCancelRequest msg_internal(msg);
1185     return global_func_table_.wifi_nan_publish_cancel_request(
1186         id, getIfaceHandle(iface_name), &msg_internal);
1187 }
1188
1189 wifi_error WifiLegacyHal::nanSubscribeRequest(const std::string& iface_name,
1190                                               transaction_id id,
1191                                               const NanSubscribeRequest& msg) {
1192     NanSubscribeRequest msg_internal(msg);
1193     return global_func_table_.wifi_nan_subscribe_request(
1194         id, getIfaceHandle(iface_name), &msg_internal);
1195 }
1196
1197 wifi_error WifiLegacyHal::nanSubscribeCancelRequest(
1198     const std::string& iface_name, transaction_id id,
1199     const NanSubscribeCancelRequest& msg) {
1200     NanSubscribeCancelRequest msg_internal(msg);
1201     return global_func_table_.wifi_nan_subscribe_cancel_request(
1202         id, getIfaceHandle(iface_name), &msg_internal);
1203 }
1204
1205 wifi_error WifiLegacyHal::nanTransmitFollowupRequest(
1206     const std::string& iface_name, transaction_id id,
1207     const NanTransmitFollowupRequest& msg) {
1208     NanTransmitFollowupRequest msg_internal(msg);
1209     return global_func_table_.wifi_nan_transmit_followup_request(
1210         id, getIfaceHandle(iface_name), &msg_internal);
1211 }
1212
1213 wifi_error WifiLegacyHal::nanStatsRequest(const std::string& iface_name,
1214                                           transaction_id id,
1215                                           const NanStatsRequest& msg) {
1216     NanStatsRequest msg_internal(msg);
1217     return global_func_table_.wifi_nan_stats_request(
1218         id, getIfaceHandle(iface_name), &msg_internal);
1219 }
1220
1221 wifi_error WifiLegacyHal::nanConfigRequest(const std::string& iface_name,
1222                                            transaction_id id,
1223                                            const NanConfigRequest& msg) {
1224     NanConfigRequest msg_internal(msg);
1225     return global_func_table_.wifi_nan_config_request(
1226         id, getIfaceHandle(iface_name), &msg_internal);
1227 }
1228
1229 wifi_error WifiLegacyHal::nanTcaRequest(const std::string& iface_name,
1230                                         transaction_id id,
1231                                         const NanTCARequest& msg) {
1232     NanTCARequest msg_internal(msg);
1233     return global_func_table_.wifi_nan_tca_request(
1234         id, getIfaceHandle(iface_name), &msg_internal);
1235 }
1236
1237 wifi_error WifiLegacyHal::nanBeaconSdfPayloadRequest(
1238     const std::string& iface_name, transaction_id id,
1239     const NanBeaconSdfPayloadRequest& msg) {
1240     NanBeaconSdfPayloadRequest msg_internal(msg);
1241     return global_func_table_.wifi_nan_beacon_sdf_payload_request(
1242         id, getIfaceHandle(iface_name), &msg_internal);
1243 }
1244
1245 std::pair<wifi_error, NanVersion> WifiLegacyHal::nanGetVersion() {
1246     NanVersion version;
1247     wifi_error status =
1248         global_func_table_.wifi_nan_get_version(global_handle_, &version);
1249     return {status, version};
1250 }
1251
1252 wifi_error WifiLegacyHal::nanGetCapabilities(const std::string& iface_name,
1253                                              transaction_id id) {
1254     return global_func_table_.wifi_nan_get_capabilities(
1255         id, getIfaceHandle(iface_name));
1256 }
1257
1258 wifi_error WifiLegacyHal::nanDataInterfaceCreate(
1259     const std::string& iface_name, transaction_id id,
1260     const std::string& data_iface_name) {
1261     return global_func_table_.wifi_nan_data_interface_create(
1262         id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
1263 }
1264
1265 wifi_error WifiLegacyHal::nanDataInterfaceDelete(
1266     const std::string& iface_name, transaction_id id,
1267     const std::string& data_iface_name) {
1268     return global_func_table_.wifi_nan_data_interface_delete(
1269         id, getIfaceHandle(iface_name), makeCharVec(data_iface_name).data());
1270 }
1271
1272 wifi_error WifiLegacyHal::nanDataRequestInitiator(
1273     const std::string& iface_name, transaction_id id,
1274     const NanDataPathInitiatorRequest& msg) {
1275     NanDataPathInitiatorRequest msg_internal(msg);
1276     return global_func_table_.wifi_nan_data_request_initiator(
1277         id, getIfaceHandle(iface_name), &msg_internal);
1278 }
1279
1280 wifi_error WifiLegacyHal::nanDataIndicationResponse(
1281     const std::string& iface_name, transaction_id id,
1282     const NanDataPathIndicationResponse& msg) {
1283     NanDataPathIndicationResponse msg_internal(msg);
1284     return global_func_table_.wifi_nan_data_indication_response(
1285         id, getIfaceHandle(iface_name), &msg_internal);
1286 }
1287
1288 typedef struct {
1289     u8 num_ndp_instances;
1290     NanDataPathId ndp_instance_id;
1291 } NanDataPathEndSingleNdpIdRequest;
1292
1293 wifi_error WifiLegacyHal::nanDataEnd(const std::string& iface_name,
1294                                      transaction_id id,
1295                                      uint32_t ndpInstanceId) {
1296     NanDataPathEndSingleNdpIdRequest msg;
1297     msg.num_ndp_instances = 1;
1298     msg.ndp_instance_id = ndpInstanceId;
1299     wifi_error status = global_func_table_.wifi_nan_data_end(
1300         id, getIfaceHandle(iface_name), (NanDataPathEndRequest*)&msg);
1301     return status;
1302 }
1303
1304 wifi_error WifiLegacyHal::setCountryCode(const std::string& iface_name,
1305                                          std::array<int8_t, 2> code) {
1306     std::string code_str(code.data(), code.data() + code.size());
1307     return global_func_table_.wifi_set_country_code(getIfaceHandle(iface_name),
1308                                                     code_str.c_str());
1309 }
1310
1311 wifi_error WifiLegacyHal::retrieveIfaceHandles() {
1312     wifi_interface_handle* iface_handles = nullptr;
1313     int num_iface_handles = 0;
1314     wifi_error status = global_func_table_.wifi_get_ifaces(
1315         global_handle_, &num_iface_handles, &iface_handles);
1316     if (status != WIFI_SUCCESS) {
1317         LOG(ERROR) << "Failed to enumerate interface handles";
1318         return status;
1319     }
1320     for (int i = 0; i < num_iface_handles; ++i) {
1321         std::array<char, IFNAMSIZ> iface_name_arr = {};
1322         status = global_func_table_.wifi_get_iface_name(
1323             iface_handles[i], iface_name_arr.data(), iface_name_arr.size());
1324         if (status != WIFI_SUCCESS) {
1325             LOG(WARNING) << "Failed to get interface handle name";
1326             continue;
1327         }
1328         // Assuming the interface name is null terminated since the legacy HAL
1329         // API does not return a size.
1330         std::string iface_name(iface_name_arr.data());
1331         LOG(INFO) << "Adding interface handle for " << iface_name;
1332         iface_name_to_handle_[iface_name] = iface_handles[i];
1333     }
1334     return WIFI_SUCCESS;
1335 }
1336
1337 wifi_interface_handle WifiLegacyHal::getIfaceHandle(
1338     const std::string& iface_name) {
1339     const auto iface_handle_iter = iface_name_to_handle_.find(iface_name);
1340     if (iface_handle_iter == iface_name_to_handle_.end()) {
1341         LOG(ERROR) << "Unknown iface name: " << iface_name;
1342         return nullptr;
1343     }
1344     return iface_handle_iter->second;
1345 }
1346
1347 void WifiLegacyHal::runEventLoop() {
1348     LOG(DEBUG) << "Starting legacy HAL event loop";
1349     global_func_table_.wifi_event_loop(global_handle_);
1350     const auto lock = hidl_sync_util::acquireGlobalLock();
1351     if (!awaiting_event_loop_termination_) {
1352         LOG(FATAL)
1353             << "Legacy HAL event loop terminated, but HAL was not stopping";
1354     }
1355     LOG(DEBUG) << "Legacy HAL event loop terminated";
1356     awaiting_event_loop_termination_ = false;
1357     stop_wait_cv_.notify_one();
1358 }
1359
1360 std::pair<wifi_error, std::vector<wifi_cached_scan_results>>
1361 WifiLegacyHal::getGscanCachedResults(const std::string& iface_name) {
1362     std::vector<wifi_cached_scan_results> cached_scan_results;
1363     cached_scan_results.resize(kMaxCachedGscanResults);
1364     int32_t num_results = 0;
1365     wifi_error status = global_func_table_.wifi_get_cached_gscan_results(
1366         getIfaceHandle(iface_name), true /* always flush */,
1367         cached_scan_results.size(), cached_scan_results.data(), &num_results);
1368     CHECK(num_results >= 0 &&
1369           static_cast<uint32_t>(num_results) <= kMaxCachedGscanResults);
1370     cached_scan_results.resize(num_results);
1371     // Check for invalid IE lengths in these cached scan results and correct it.
1372     for (auto& cached_scan_result : cached_scan_results) {
1373         int num_scan_results = cached_scan_result.num_results;
1374         for (int i = 0; i < num_scan_results; i++) {
1375             auto& scan_result = cached_scan_result.results[i];
1376             if (scan_result.ie_length > 0) {
1377                 LOG(DEBUG) << "Cached scan result has non-zero IE length "
1378                            << scan_result.ie_length;
1379                 scan_result.ie_length = 0;
1380             }
1381         }
1382     }
1383     return {status, std::move(cached_scan_results)};
1384 }
1385
1386 void WifiLegacyHal::invalidate() {
1387     global_handle_ = nullptr;
1388     iface_name_to_handle_.clear();
1389     on_driver_memory_dump_internal_callback = nullptr;
1390     on_firmware_memory_dump_internal_callback = nullptr;
1391     on_gscan_event_internal_callback = nullptr;
1392     on_gscan_full_result_internal_callback = nullptr;
1393     on_link_layer_stats_result_internal_callback = nullptr;
1394     on_rssi_threshold_breached_internal_callback = nullptr;
1395     on_ring_buffer_data_internal_callback = nullptr;
1396     on_error_alert_internal_callback = nullptr;
1397     on_radio_mode_change_internal_callback = nullptr;
1398     on_rtt_results_internal_callback = nullptr;
1399     on_nan_notify_response_user_callback = nullptr;
1400     on_nan_event_publish_terminated_user_callback = nullptr;
1401     on_nan_event_match_user_callback = nullptr;
1402     on_nan_event_match_expired_user_callback = nullptr;
1403     on_nan_event_subscribe_terminated_user_callback = nullptr;
1404     on_nan_event_followup_user_callback = nullptr;
1405     on_nan_event_disc_eng_event_user_callback = nullptr;
1406     on_nan_event_disabled_user_callback = nullptr;
1407     on_nan_event_tca_user_callback = nullptr;
1408     on_nan_event_beacon_sdf_payload_user_callback = nullptr;
1409     on_nan_event_data_path_request_user_callback = nullptr;
1410     on_nan_event_data_path_confirm_user_callback = nullptr;
1411     on_nan_event_data_path_end_user_callback = nullptr;
1412     on_nan_event_transmit_follow_up_user_callback = nullptr;
1413     on_nan_event_range_request_user_callback = nullptr;
1414     on_nan_event_range_report_user_callback = nullptr;
1415     on_nan_event_schedule_update_user_callback = nullptr;
1416 }
1417
1418 }  // namespace legacy_hal
1419 }  // namespace implementation
1420 }  // namespace V1_2
1421 }  // namespace wifi
1422 }  // namespace hardware
1423 }  // namespace android