1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <android-base/logging.h>
18 
19 #include "hidl_return_util.h"
20 #include "hidl_struct_util.h"
21 #include "wifi_sta_iface.h"
22 #include "wifi_status_util.h"
23 
24 namespace android {
25 namespace hardware {
26 namespace wifi {
27 namespace V1_0 {
28 namespace implementation {
29 using hidl_return_util::validateAndCall;
30 
WifiStaIface(const std::string & ifname,const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)31 WifiStaIface::WifiStaIface(
32     const std::string& ifname,
33     const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
34     : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) {
35   // Turn on DFS channel usage for STA iface.
36   legacy_hal::wifi_error legacy_status =
37       legacy_hal_.lock()->setDfsFlag(true);
38   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
39     LOG(ERROR) << "Failed to set DFS flag; DFS channels may be unavailable.";
40   }
41 }
42 
invalidate()43 void WifiStaIface::invalidate() {
44   legacy_hal_.reset();
45   event_cb_handler_.invalidate();
46   is_valid_ = false;
47 }
48 
isValid()49 bool WifiStaIface::isValid() {
50   return is_valid_;
51 }
52 
getEventCallbacks()53 std::set<sp<IWifiStaIfaceEventCallback>> WifiStaIface::getEventCallbacks() {
54   return event_cb_handler_.getCallbacks();
55 }
56 
getName(getName_cb hidl_status_cb)57 Return<void> WifiStaIface::getName(getName_cb hidl_status_cb) {
58   return validateAndCall(this,
59                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
60                          &WifiStaIface::getNameInternal,
61                          hidl_status_cb);
62 }
63 
getType(getType_cb hidl_status_cb)64 Return<void> WifiStaIface::getType(getType_cb hidl_status_cb) {
65   return validateAndCall(this,
66                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
67                          &WifiStaIface::getTypeInternal,
68                          hidl_status_cb);
69 }
70 
registerEventCallback(const sp<IWifiStaIfaceEventCallback> & callback,registerEventCallback_cb hidl_status_cb)71 Return<void> WifiStaIface::registerEventCallback(
72     const sp<IWifiStaIfaceEventCallback>& callback,
73     registerEventCallback_cb hidl_status_cb) {
74   return validateAndCall(this,
75                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
76                          &WifiStaIface::registerEventCallbackInternal,
77                          hidl_status_cb,
78                          callback);
79 }
80 
getCapabilities(getCapabilities_cb hidl_status_cb)81 Return<void> WifiStaIface::getCapabilities(getCapabilities_cb hidl_status_cb) {
82   return validateAndCall(this,
83                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
84                          &WifiStaIface::getCapabilitiesInternal,
85                          hidl_status_cb);
86 }
87 
getApfPacketFilterCapabilities(getApfPacketFilterCapabilities_cb hidl_status_cb)88 Return<void> WifiStaIface::getApfPacketFilterCapabilities(
89     getApfPacketFilterCapabilities_cb hidl_status_cb) {
90   return validateAndCall(this,
91                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
92                          &WifiStaIface::getApfPacketFilterCapabilitiesInternal,
93                          hidl_status_cb);
94 }
95 
installApfPacketFilter(uint32_t cmd_id,const hidl_vec<uint8_t> & program,installApfPacketFilter_cb hidl_status_cb)96 Return<void> WifiStaIface::installApfPacketFilter(
97     uint32_t cmd_id,
98     const hidl_vec<uint8_t>& program,
99     installApfPacketFilter_cb hidl_status_cb) {
100   return validateAndCall(this,
101                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
102                          &WifiStaIface::installApfPacketFilterInternal,
103                          hidl_status_cb,
104                          cmd_id,
105                          program);
106 }
107 
getBackgroundScanCapabilities(getBackgroundScanCapabilities_cb hidl_status_cb)108 Return<void> WifiStaIface::getBackgroundScanCapabilities(
109     getBackgroundScanCapabilities_cb hidl_status_cb) {
110   return validateAndCall(this,
111                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
112                          &WifiStaIface::getBackgroundScanCapabilitiesInternal,
113                          hidl_status_cb);
114 }
115 
getValidFrequenciesForBand(WifiBand band,getValidFrequenciesForBand_cb hidl_status_cb)116 Return<void> WifiStaIface::getValidFrequenciesForBand(
117     WifiBand band, getValidFrequenciesForBand_cb hidl_status_cb) {
118   return validateAndCall(this,
119                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
120                          &WifiStaIface::getValidFrequenciesForBandInternal,
121                          hidl_status_cb,
122                          band);
123 }
124 
startBackgroundScan(uint32_t cmd_id,const StaBackgroundScanParameters & params,startBackgroundScan_cb hidl_status_cb)125 Return<void> WifiStaIface::startBackgroundScan(
126     uint32_t cmd_id,
127     const StaBackgroundScanParameters& params,
128     startBackgroundScan_cb hidl_status_cb) {
129   return validateAndCall(this,
130                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
131                          &WifiStaIface::startBackgroundScanInternal,
132                          hidl_status_cb,
133                          cmd_id,
134                          params);
135 }
136 
stopBackgroundScan(uint32_t cmd_id,stopBackgroundScan_cb hidl_status_cb)137 Return<void> WifiStaIface::stopBackgroundScan(
138     uint32_t cmd_id, stopBackgroundScan_cb hidl_status_cb) {
139   return validateAndCall(this,
140                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
141                          &WifiStaIface::stopBackgroundScanInternal,
142                          hidl_status_cb,
143                          cmd_id);
144 }
145 
enableLinkLayerStatsCollection(bool debug,enableLinkLayerStatsCollection_cb hidl_status_cb)146 Return<void> WifiStaIface::enableLinkLayerStatsCollection(
147     bool debug, enableLinkLayerStatsCollection_cb hidl_status_cb) {
148   return validateAndCall(this,
149                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
150                          &WifiStaIface::enableLinkLayerStatsCollectionInternal,
151                          hidl_status_cb,
152                          debug);
153 }
154 
disableLinkLayerStatsCollection(disableLinkLayerStatsCollection_cb hidl_status_cb)155 Return<void> WifiStaIface::disableLinkLayerStatsCollection(
156     disableLinkLayerStatsCollection_cb hidl_status_cb) {
157   return validateAndCall(this,
158                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
159                          &WifiStaIface::disableLinkLayerStatsCollectionInternal,
160                          hidl_status_cb);
161 }
162 
getLinkLayerStats(getLinkLayerStats_cb hidl_status_cb)163 Return<void> WifiStaIface::getLinkLayerStats(
164     getLinkLayerStats_cb hidl_status_cb) {
165   return validateAndCall(this,
166                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
167                          &WifiStaIface::getLinkLayerStatsInternal,
168                          hidl_status_cb);
169 }
170 
startRssiMonitoring(uint32_t cmd_id,int32_t max_rssi,int32_t min_rssi,startRssiMonitoring_cb hidl_status_cb)171 Return<void> WifiStaIface::startRssiMonitoring(
172     uint32_t cmd_id,
173     int32_t max_rssi,
174     int32_t min_rssi,
175     startRssiMonitoring_cb hidl_status_cb) {
176   return validateAndCall(this,
177                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
178                          &WifiStaIface::startRssiMonitoringInternal,
179                          hidl_status_cb,
180                          cmd_id,
181                          max_rssi,
182                          min_rssi);
183 }
184 
stopRssiMonitoring(uint32_t cmd_id,stopRssiMonitoring_cb hidl_status_cb)185 Return<void> WifiStaIface::stopRssiMonitoring(
186     uint32_t cmd_id, stopRssiMonitoring_cb hidl_status_cb) {
187   return validateAndCall(this,
188                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
189                          &WifiStaIface::stopRssiMonitoringInternal,
190                          hidl_status_cb,
191                          cmd_id);
192 }
193 
getRoamingCapabilities(getRoamingCapabilities_cb hidl_status_cb)194 Return<void> WifiStaIface::getRoamingCapabilities(
195     getRoamingCapabilities_cb hidl_status_cb) {
196   return validateAndCall(this,
197                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
198                          &WifiStaIface::getRoamingCapabilitiesInternal,
199                          hidl_status_cb);
200 }
201 
configureRoaming(const StaRoamingConfig & config,configureRoaming_cb hidl_status_cb)202 Return<void> WifiStaIface::configureRoaming(
203     const StaRoamingConfig& config, configureRoaming_cb hidl_status_cb) {
204   return validateAndCall(this,
205                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
206                          &WifiStaIface::configureRoamingInternal,
207                          hidl_status_cb,
208                          config);
209 }
210 
setRoamingState(StaRoamingState state,setRoamingState_cb hidl_status_cb)211 Return<void> WifiStaIface::setRoamingState(StaRoamingState state,
212                                            setRoamingState_cb hidl_status_cb) {
213   return validateAndCall(this,
214                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
215                          &WifiStaIface::setRoamingStateInternal,
216                          hidl_status_cb,
217                          state);
218 }
219 
enableNdOffload(bool enable,enableNdOffload_cb hidl_status_cb)220 Return<void> WifiStaIface::enableNdOffload(bool enable,
221                                            enableNdOffload_cb hidl_status_cb) {
222   return validateAndCall(this,
223                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
224                          &WifiStaIface::enableNdOffloadInternal,
225                          hidl_status_cb,
226                          enable);
227 }
228 
startSendingKeepAlivePackets(uint32_t cmd_id,const hidl_vec<uint8_t> & ip_packet_data,uint16_t ether_type,const hidl_array<uint8_t,6> & src_address,const hidl_array<uint8_t,6> & dst_address,uint32_t period_in_ms,startSendingKeepAlivePackets_cb hidl_status_cb)229 Return<void> WifiStaIface::startSendingKeepAlivePackets(
230     uint32_t cmd_id,
231     const hidl_vec<uint8_t>& ip_packet_data,
232     uint16_t ether_type,
233     const hidl_array<uint8_t, 6>& src_address,
234     const hidl_array<uint8_t, 6>& dst_address,
235     uint32_t period_in_ms,
236     startSendingKeepAlivePackets_cb hidl_status_cb) {
237   return validateAndCall(this,
238                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
239                          &WifiStaIface::startSendingKeepAlivePacketsInternal,
240                          hidl_status_cb,
241                          cmd_id,
242                          ip_packet_data,
243                          ether_type,
244                          src_address,
245                          dst_address,
246                          period_in_ms);
247 }
248 
stopSendingKeepAlivePackets(uint32_t cmd_id,stopSendingKeepAlivePackets_cb hidl_status_cb)249 Return<void> WifiStaIface::stopSendingKeepAlivePackets(
250     uint32_t cmd_id, stopSendingKeepAlivePackets_cb hidl_status_cb) {
251   return validateAndCall(this,
252                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
253                          &WifiStaIface::stopSendingKeepAlivePacketsInternal,
254                          hidl_status_cb,
255                          cmd_id);
256 }
257 
setScanningMacOui(const hidl_array<uint8_t,3> & oui,setScanningMacOui_cb hidl_status_cb)258 Return<void> WifiStaIface::setScanningMacOui(
259     const hidl_array<uint8_t, 3>& oui, setScanningMacOui_cb hidl_status_cb) {
260   return validateAndCall(this,
261                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
262                          &WifiStaIface::setScanningMacOuiInternal,
263                          hidl_status_cb,
264                          oui);
265 }
266 
startDebugPacketFateMonitoring(startDebugPacketFateMonitoring_cb hidl_status_cb)267 Return<void> WifiStaIface::startDebugPacketFateMonitoring(
268     startDebugPacketFateMonitoring_cb hidl_status_cb) {
269   return validateAndCall(this,
270                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
271                          &WifiStaIface::startDebugPacketFateMonitoringInternal,
272                          hidl_status_cb);
273 }
274 
getDebugTxPacketFates(getDebugTxPacketFates_cb hidl_status_cb)275 Return<void> WifiStaIface::getDebugTxPacketFates(
276     getDebugTxPacketFates_cb hidl_status_cb) {
277   return validateAndCall(this,
278                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
279                          &WifiStaIface::getDebugTxPacketFatesInternal,
280                          hidl_status_cb);
281 }
282 
getDebugRxPacketFates(getDebugRxPacketFates_cb hidl_status_cb)283 Return<void> WifiStaIface::getDebugRxPacketFates(
284     getDebugRxPacketFates_cb hidl_status_cb) {
285   return validateAndCall(this,
286                          WifiStatusCode::ERROR_WIFI_IFACE_INVALID,
287                          &WifiStaIface::getDebugRxPacketFatesInternal,
288                          hidl_status_cb);
289 }
290 
getNameInternal()291 std::pair<WifiStatus, std::string> WifiStaIface::getNameInternal() {
292   return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_};
293 }
294 
getTypeInternal()295 std::pair<WifiStatus, IfaceType> WifiStaIface::getTypeInternal() {
296   return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::STA};
297 }
298 
registerEventCallbackInternal(const sp<IWifiStaIfaceEventCallback> & callback)299 WifiStatus WifiStaIface::registerEventCallbackInternal(
300     const sp<IWifiStaIfaceEventCallback>& callback) {
301   if (!event_cb_handler_.addCallback(callback)) {
302     return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
303   }
304   return createWifiStatus(WifiStatusCode::SUCCESS);
305 }
306 
getCapabilitiesInternal()307 std::pair<WifiStatus, uint32_t> WifiStaIface::getCapabilitiesInternal() {
308   legacy_hal::wifi_error legacy_status;
309   uint32_t legacy_feature_set;
310   std::tie(legacy_status, legacy_feature_set) =
311       legacy_hal_.lock()->getSupportedFeatureSet();
312   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
313     return {createWifiStatusFromLegacyError(legacy_status), 0};
314   }
315   uint32_t legacy_logger_feature_set;
316   std::tie(legacy_status, legacy_logger_feature_set) =
317       legacy_hal_.lock()->getLoggerSupportedFeatureSet();
318   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
319     // some devices don't support querying logger feature set
320     legacy_logger_feature_set = 0;
321   }
322   uint32_t hidl_caps;
323   if (!hidl_struct_util::convertLegacyFeaturesToHidlStaCapabilities(
324           legacy_feature_set, legacy_logger_feature_set, &hidl_caps)) {
325     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
326   }
327   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
328 }
329 
330 std::pair<WifiStatus, StaApfPacketFilterCapabilities>
getApfPacketFilterCapabilitiesInternal()331 WifiStaIface::getApfPacketFilterCapabilitiesInternal() {
332   legacy_hal::wifi_error legacy_status;
333   legacy_hal::PacketFilterCapabilities legacy_caps;
334   std::tie(legacy_status, legacy_caps) =
335       legacy_hal_.lock()->getPacketFilterCapabilities();
336   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
337     return {createWifiStatusFromLegacyError(legacy_status), {}};
338   }
339   StaApfPacketFilterCapabilities hidl_caps;
340   if (!hidl_struct_util::convertLegacyApfCapabilitiesToHidl(legacy_caps,
341                                                             &hidl_caps)) {
342     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
343   }
344   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
345 }
346 
installApfPacketFilterInternal(uint32_t,const std::vector<uint8_t> & program)347 WifiStatus WifiStaIface::installApfPacketFilterInternal(
348     uint32_t /* cmd_id */, const std::vector<uint8_t>& program) {
349   legacy_hal::wifi_error legacy_status =
350       legacy_hal_.lock()->setPacketFilter(program);
351   return createWifiStatusFromLegacyError(legacy_status);
352 }
353 
354 std::pair<WifiStatus, StaBackgroundScanCapabilities>
getBackgroundScanCapabilitiesInternal()355 WifiStaIface::getBackgroundScanCapabilitiesInternal() {
356   legacy_hal::wifi_error legacy_status;
357   legacy_hal::wifi_gscan_capabilities legacy_caps;
358   std::tie(legacy_status, legacy_caps) =
359       legacy_hal_.lock()->getGscanCapabilities();
360   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
361     return {createWifiStatusFromLegacyError(legacy_status), {}};
362   }
363   StaBackgroundScanCapabilities hidl_caps;
364   if (!hidl_struct_util::convertLegacyGscanCapabilitiesToHidl(legacy_caps,
365                                                               &hidl_caps)) {
366     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
367   }
368   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
369 }
370 
371 std::pair<WifiStatus, std::vector<WifiChannelInMhz>>
getValidFrequenciesForBandInternal(WifiBand band)372 WifiStaIface::getValidFrequenciesForBandInternal(WifiBand band) {
373   static_assert(sizeof(WifiChannelInMhz) == sizeof(uint32_t), "Size mismatch");
374   legacy_hal::wifi_error legacy_status;
375   std::vector<uint32_t> valid_frequencies;
376   std::tie(legacy_status, valid_frequencies) =
377       legacy_hal_.lock()->getValidFrequenciesForBand(
378           hidl_struct_util::convertHidlWifiBandToLegacy(band));
379   return {createWifiStatusFromLegacyError(legacy_status), valid_frequencies};
380 }
381 
startBackgroundScanInternal(uint32_t cmd_id,const StaBackgroundScanParameters & params)382 WifiStatus WifiStaIface::startBackgroundScanInternal(
383     uint32_t cmd_id, const StaBackgroundScanParameters& params) {
384   legacy_hal::wifi_scan_cmd_params legacy_params;
385   if (!hidl_struct_util::convertHidlGscanParamsToLegacy(params,
386                                                         &legacy_params)) {
387     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
388   }
389   android::wp<WifiStaIface> weak_ptr_this(this);
390   const auto& on_failure_callback =
391       [weak_ptr_this](legacy_hal::wifi_request_id id) {
392         const auto shared_ptr_this = weak_ptr_this.promote();
393         if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
394           LOG(ERROR) << "Callback invoked on an invalid object";
395           return;
396         }
397         for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
398           if (!callback->onBackgroundScanFailure(id).isOk()) {
399             LOG(ERROR) << "Failed to invoke onBackgroundScanFailure callback";
400           }
401         }
402       };
403   const auto& on_results_callback = [weak_ptr_this](
404       legacy_hal::wifi_request_id id,
405       const std::vector<legacy_hal::wifi_cached_scan_results>& results) {
406     const auto shared_ptr_this = weak_ptr_this.promote();
407     if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
408       LOG(ERROR) << "Callback invoked on an invalid object";
409       return;
410     }
411     std::vector<StaScanData> hidl_scan_datas;
412     if (!hidl_struct_util::convertLegacyVectorOfCachedGscanResultsToHidl(
413             results, &hidl_scan_datas)) {
414       LOG(ERROR) << "Failed to convert scan results to HIDL structs";
415       return;
416     }
417     for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
418       if (!callback->onBackgroundScanResults(id, hidl_scan_datas).isOk()) {
419         LOG(ERROR) << "Failed to invoke onBackgroundScanResults callback";
420       }
421     }
422   };
423   const auto& on_full_result_callback = [weak_ptr_this](
424       legacy_hal::wifi_request_id id,
425       const legacy_hal::wifi_scan_result* result,
426       uint32_t buckets_scanned) {
427     const auto shared_ptr_this = weak_ptr_this.promote();
428     if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
429       LOG(ERROR) << "Callback invoked on an invalid object";
430       return;
431     }
432     StaScanResult hidl_scan_result;
433     if (!hidl_struct_util::convertLegacyGscanResultToHidl(
434             *result, true, &hidl_scan_result)) {
435       LOG(ERROR) << "Failed to convert full scan results to HIDL structs";
436       return;
437     }
438     for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
439       if (!callback->onBackgroundFullScanResult(
440               id, buckets_scanned, hidl_scan_result).isOk()) {
441         LOG(ERROR) << "Failed to invoke onBackgroundFullScanResult callback";
442       }
443     }
444   };
445   legacy_hal::wifi_error legacy_status =
446       legacy_hal_.lock()->startGscan(cmd_id,
447                                      legacy_params,
448                                      on_failure_callback,
449                                      on_results_callback,
450                                      on_full_result_callback);
451   return createWifiStatusFromLegacyError(legacy_status);
452 }
453 
stopBackgroundScanInternal(uint32_t cmd_id)454 WifiStatus WifiStaIface::stopBackgroundScanInternal(uint32_t cmd_id) {
455   legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->stopGscan(cmd_id);
456   return createWifiStatusFromLegacyError(legacy_status);
457 }
458 
enableLinkLayerStatsCollectionInternal(bool debug)459 WifiStatus WifiStaIface::enableLinkLayerStatsCollectionInternal(bool debug) {
460   legacy_hal::wifi_error legacy_status =
461       legacy_hal_.lock()->enableLinkLayerStats(debug);
462   return createWifiStatusFromLegacyError(legacy_status);
463 }
464 
disableLinkLayerStatsCollectionInternal()465 WifiStatus WifiStaIface::disableLinkLayerStatsCollectionInternal() {
466   legacy_hal::wifi_error legacy_status =
467       legacy_hal_.lock()->disableLinkLayerStats();
468   return createWifiStatusFromLegacyError(legacy_status);
469 }
470 
471 std::pair<WifiStatus, StaLinkLayerStats>
getLinkLayerStatsInternal()472 WifiStaIface::getLinkLayerStatsInternal() {
473   legacy_hal::wifi_error legacy_status;
474   legacy_hal::LinkLayerStats legacy_stats;
475   std::tie(legacy_status, legacy_stats) =
476       legacy_hal_.lock()->getLinkLayerStats();
477   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
478     return {createWifiStatusFromLegacyError(legacy_status), {}};
479   }
480   StaLinkLayerStats hidl_stats;
481   if (!hidl_struct_util::convertLegacyLinkLayerStatsToHidl(legacy_stats,
482                                                            &hidl_stats)) {
483     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
484   }
485   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
486 }
487 
startRssiMonitoringInternal(uint32_t cmd_id,int32_t max_rssi,int32_t min_rssi)488 WifiStatus WifiStaIface::startRssiMonitoringInternal(uint32_t cmd_id,
489                                                      int32_t max_rssi,
490                                                      int32_t min_rssi) {
491   android::wp<WifiStaIface> weak_ptr_this(this);
492   const auto& on_threshold_breached_callback = [weak_ptr_this](
493       legacy_hal::wifi_request_id id,
494       std::array<uint8_t, 6> bssid,
495       int8_t rssi) {
496     const auto shared_ptr_this = weak_ptr_this.promote();
497     if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
498       LOG(ERROR) << "Callback invoked on an invalid object";
499       return;
500     }
501     for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
502       if (!callback->onRssiThresholdBreached(id, bssid, rssi).isOk()) {
503         LOG(ERROR) << "Failed to invoke onRssiThresholdBreached callback";
504       }
505     }
506   };
507   legacy_hal::wifi_error legacy_status =
508       legacy_hal_.lock()->startRssiMonitoring(
509           cmd_id, max_rssi, min_rssi, on_threshold_breached_callback);
510   return createWifiStatusFromLegacyError(legacy_status);
511 }
512 
stopRssiMonitoringInternal(uint32_t cmd_id)513 WifiStatus WifiStaIface::stopRssiMonitoringInternal(uint32_t cmd_id) {
514   legacy_hal::wifi_error legacy_status =
515       legacy_hal_.lock()->stopRssiMonitoring(cmd_id);
516   return createWifiStatusFromLegacyError(legacy_status);
517 }
518 
519 std::pair<WifiStatus, StaRoamingCapabilities>
getRoamingCapabilitiesInternal()520 WifiStaIface::getRoamingCapabilitiesInternal() {
521   legacy_hal::wifi_error legacy_status;
522   legacy_hal::wifi_roaming_capabilities legacy_caps;
523   std::tie(legacy_status, legacy_caps) =
524       legacy_hal_.lock()->getRoamingCapabilities();
525   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
526     return {createWifiStatusFromLegacyError(legacy_status), {}};
527   }
528   StaRoamingCapabilities hidl_caps;
529   if (!hidl_struct_util::convertLegacyRoamingCapabilitiesToHidl(legacy_caps,
530                                                                 &hidl_caps)) {
531     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
532   }
533   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
534 }
535 
configureRoamingInternal(const StaRoamingConfig & config)536 WifiStatus WifiStaIface::configureRoamingInternal(
537     const StaRoamingConfig& config) {
538   legacy_hal::wifi_roaming_config legacy_config;
539   if (!hidl_struct_util::convertHidlRoamingConfigToLegacy(config,
540                                                           &legacy_config)) {
541     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
542   }
543   legacy_hal::wifi_error legacy_status =
544       legacy_hal_.lock()->configureRoaming(legacy_config);
545   return createWifiStatusFromLegacyError(legacy_status);
546 }
547 
setRoamingStateInternal(StaRoamingState state)548 WifiStatus WifiStaIface::setRoamingStateInternal(StaRoamingState state) {
549   legacy_hal::wifi_error legacy_status =
550       legacy_hal_.lock()->enableFirmwareRoaming(
551           hidl_struct_util::convertHidlRoamingStateToLegacy(state));
552   return createWifiStatusFromLegacyError(legacy_status);
553 }
554 
enableNdOffloadInternal(bool enable)555 WifiStatus WifiStaIface::enableNdOffloadInternal(bool enable) {
556   legacy_hal::wifi_error legacy_status =
557       legacy_hal_.lock()->configureNdOffload(enable);
558   return createWifiStatusFromLegacyError(legacy_status);
559 }
560 
startSendingKeepAlivePacketsInternal(uint32_t cmd_id,const std::vector<uint8_t> & ip_packet_data,uint16_t,const std::array<uint8_t,6> & src_address,const std::array<uint8_t,6> & dst_address,uint32_t period_in_ms)561 WifiStatus WifiStaIface::startSendingKeepAlivePacketsInternal(
562     uint32_t cmd_id,
563     const std::vector<uint8_t>& ip_packet_data,
564     uint16_t /* ether_type */,
565     const std::array<uint8_t, 6>& src_address,
566     const std::array<uint8_t, 6>& dst_address,
567     uint32_t period_in_ms) {
568   legacy_hal::wifi_error legacy_status =
569       legacy_hal_.lock()->startSendingOffloadedPacket(
570           cmd_id, ip_packet_data, src_address, dst_address, period_in_ms);
571   return createWifiStatusFromLegacyError(legacy_status);
572 }
573 
stopSendingKeepAlivePacketsInternal(uint32_t cmd_id)574 WifiStatus WifiStaIface::stopSendingKeepAlivePacketsInternal(uint32_t cmd_id) {
575   legacy_hal::wifi_error legacy_status =
576       legacy_hal_.lock()->stopSendingOffloadedPacket(cmd_id);
577   return createWifiStatusFromLegacyError(legacy_status);
578 }
579 
setScanningMacOuiInternal(const std::array<uint8_t,3> & oui)580 WifiStatus WifiStaIface::setScanningMacOuiInternal(
581     const std::array<uint8_t, 3>& oui) {
582   legacy_hal::wifi_error legacy_status =
583       legacy_hal_.lock()->setScanningMacOui(oui);
584   return createWifiStatusFromLegacyError(legacy_status);
585 }
586 
startDebugPacketFateMonitoringInternal()587 WifiStatus WifiStaIface::startDebugPacketFateMonitoringInternal() {
588   legacy_hal::wifi_error legacy_status =
589       legacy_hal_.lock()->startPktFateMonitoring();
590   return createWifiStatusFromLegacyError(legacy_status);
591 }
592 
593 std::pair<WifiStatus, std::vector<WifiDebugTxPacketFateReport>>
getDebugTxPacketFatesInternal()594 WifiStaIface::getDebugTxPacketFatesInternal() {
595   legacy_hal::wifi_error legacy_status;
596   std::vector<legacy_hal::wifi_tx_report> legacy_fates;
597   std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getTxPktFates();
598   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
599     return {createWifiStatusFromLegacyError(legacy_status), {}};
600   }
601   std::vector<WifiDebugTxPacketFateReport> hidl_fates;
602   if (!hidl_struct_util::convertLegacyVectorOfDebugTxPacketFateToHidl(
603           legacy_fates, &hidl_fates)) {
604     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
605   }
606   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
607 }
608 
609 std::pair<WifiStatus, std::vector<WifiDebugRxPacketFateReport>>
getDebugRxPacketFatesInternal()610 WifiStaIface::getDebugRxPacketFatesInternal() {
611   legacy_hal::wifi_error legacy_status;
612   std::vector<legacy_hal::wifi_rx_report> legacy_fates;
613   std::tie(legacy_status, legacy_fates) = legacy_hal_.lock()->getRxPktFates();
614   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
615     return {createWifiStatusFromLegacyError(legacy_status), {}};
616   }
617   std::vector<WifiDebugRxPacketFateReport> hidl_fates;
618   if (!hidl_struct_util::convertLegacyVectorOfDebugRxPacketFateToHidl(
619           legacy_fates, &hidl_fates)) {
620     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
621   }
622   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_fates};
623 }
624 
625 }  // namespace implementation
626 }  // namespace V1_0
627 }  // namespace wifi
628 }  // namespace hardware
629 }  // namespace android
630