1 /*
2  * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "wifi_scan_service_impl.h"
17 #include "define.h"
18 #include "wifi_auth_center.h"
19 #include "wifi_config_center.h"
20 #ifdef OHOS_ARCH_LITE
21 #include "wifi_internal_event_dispatcher_lite.h"
22 #else
23 #include "wifi_internal_event_dispatcher.h"
24 #endif
25 #include "wifi_internal_msg.h"
26 #include "wifi_logger.h"
27 #include "wifi_manager.h"
28 #include "wifi_msg.h"
29 #include "wifi_permission_utils.h"
30 #include "wifi_scan_callback_proxy.h"
31 #include "wifi_service_manager.h"
32 #include "wifi_sta_hal_interface.h"
33 #include "wifi_common_util.h"
34 #include "wifi_hisysevent.h"
35 
36 DEFINE_WIFILOG_SCAN_LABEL("WifiScanServiceImpl");
37 namespace OHOS {
38 namespace Wifi {
39 
40 #ifdef OHOS_ARCH_LITE
41 std::mutex WifiScanServiceImpl::g_instanceLock;
42 std::shared_ptr<WifiScanServiceImpl> WifiScanServiceImpl::g_instance = nullptr;
GetInstance()43 std::shared_ptr<WifiScanServiceImpl> WifiScanServiceImpl::GetInstance()
44 {
45     if (g_instance == nullptr) {
46         std::lock_guard<std::mutex> autoLock(g_instanceLock);
47         if (g_instance == nullptr) {
48             std::shared_ptr<WifiScanServiceImpl> service = std::make_shared<WifiScanServiceImpl>();
49             g_instance = service;
50         }
51     }
52     return g_instance;
53 }
54 
OnStart()55 void WifiScanServiceImpl::OnStart()
56 {
57     if (mState == ServiceRunningState::STATE_RUNNING) {
58         WIFI_LOGW("Service has already started.");
59         return;
60     }
61 
62     WifiManager::GetInstance();
63     mState = ServiceRunningState::STATE_RUNNING;
64     WIFI_LOGI("Start scan service!");
65 }
66 
OnStop()67 void WifiScanServiceImpl::OnStop()
68 {
69     mState = ServiceRunningState::STATE_NOT_START;
70     WIFI_LOGI("Stop scan service!");
71 }
72 #endif
73 
74 
WifiScanServiceImpl()75 WifiScanServiceImpl::WifiScanServiceImpl()
76 #ifdef OHOS_ARCH_LITE
77     : mState(ServiceRunningState::STATE_NOT_START)
78 #endif
79 {}
80 
81 #ifndef OHOS_ARCH_LITE
WifiScanServiceImpl(int instId)82 WifiScanServiceImpl::WifiScanServiceImpl(int instId) : WifiScanStub(instId)
83 {}
84 #endif
85 
~WifiScanServiceImpl()86 WifiScanServiceImpl::~WifiScanServiceImpl()
87 {}
88 
SetScanControlInfo(const ScanControlInfo & info)89 ErrCode WifiScanServiceImpl::SetScanControlInfo(const ScanControlInfo &info)
90 {
91     WIFI_LOGI("WifiScanServiceImpl::SetScanControlInfo");
92     if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
93         WIFI_LOGE("SetScanControlInfo:VerifySetWifiConfigPermission PERMISSION_DENIED!");
94         return WIFI_OPT_PERMISSION_DENIED;
95     }
96     if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
97         WIFI_LOGE("SetScanControlInfo:VerifySetWifiInfoPermission PERMISSION_DENIED!");
98         return WIFI_OPT_PERMISSION_DENIED;
99     }
100 
101     WifiConfigCenter::GetInstance().GetWifiScanConfig()->SetScanControlInfo(info, m_instId);
102     if (IsScanServiceRunning()) {
103         IScanService *pService = WifiServiceManager::GetInstance().GetScanServiceInst(m_instId);
104         if (pService == nullptr) {
105             return WIFI_OPT_SCAN_NOT_OPENED;
106         }
107         return pService->OnControlStrategyChanged();
108     }
109 
110     return WIFI_OPT_SUCCESS;
111 }
112 
Scan(bool compatible)113 ErrCode WifiScanServiceImpl::Scan(bool compatible)
114 {
115     WIFI_LOGI("Scan, compatible:%{public}d", compatible);
116     if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
117         WIFI_LOGE("Scan:VerifySetWifiInfoPermission PERMISSION_DENIED!");
118 #ifndef OHOS_ARCH_LITE
119         WriteWifiScanApiFailHiSysEvent(GetBundleName(), -1);
120 #endif
121         return WIFI_OPT_PERMISSION_DENIED;
122     }
123     if (compatible) {
124         if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
125             WIFI_LOGE("Scan:VerifyGetScanInfosPermission PERMISSION_DENIED!");
126 #ifndef OHOS_ARCH_LITE
127             WriteWifiScanApiFailHiSysEvent(GetBundleName(), -1);
128 #endif
129             return WIFI_OPT_PERMISSION_DENIED;
130         }
131     } else {
132         if (!WifiAuthCenter::IsSystemAccess()) {
133             WIFI_LOGE("Scan:NOT System APP, PERMISSION_DENIED!");
134 #ifndef OHOS_ARCH_LITE
135             WriteWifiScanApiFailHiSysEvent(GetBundleName(), -1);
136 #endif
137             return WIFI_OPT_NON_SYSTEMAPP;
138         }
139         if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
140             WIFI_LOGE("Scan:VerifyWifiConnectionPermission PERMISSION_DENIED!");
141 #ifndef OHOS_ARCH_LITE
142             WriteWifiScanApiFailHiSysEvent(GetBundleName(), -1);
143 #endif
144             return WIFI_OPT_PERMISSION_DENIED;
145         }
146     }
147 
148     if (!IsScanServiceRunning()) {
149 #ifndef OHOS_ARCH_LITE
150         WriteWifiScanApiFailHiSysEvent(GetBundleName(), -1);
151 #endif
152         return WIFI_OPT_SCAN_NOT_OPENED;
153     }
154 
155 #ifndef OHOS_ARCH_LITE
156     UpdateScanMode();
157 #endif
158     return PermissionVerification();
159 }
160 
PermissionVerification()161 ErrCode WifiScanServiceImpl::PermissionVerification()
162 {
163     IScanService *pService = WifiServiceManager::GetInstance().GetScanServiceInst(m_instId);
164     if (pService == nullptr) {
165 #ifndef OHOS_ARCH_LITE
166         WriteWifiScanApiFailHiSysEvent(GetBundleName(), -1);
167 #endif
168         return WIFI_OPT_SCAN_NOT_OPENED;
169     }
170 
171     bool externFlag = true;
172 #ifndef OHOS_ARCH_LITE
173     if (WifiAuthCenter::IsNativeProcess()) {
174         externFlag = false;
175         WIFI_LOGI("Scan: native process start scan !");
176     }
177 #endif
178     if (!IsWifiScanAllowed(externFlag)) {
179         WIFI_LOGE("Scan not allowed!");
180         return WIFI_OPT_FAILED;
181     }
182     ErrCode ret = pService->Scan(externFlag);
183     if (ret != WIFI_OPT_SUCCESS) {
184         WIFI_LOGE("Scan failed: %{public}d!", static_cast<int>(ret));
185 #ifndef OHOS_ARCH_LITE
186         WriteWifiScanApiFailHiSysEvent(GetBundleName(), -1);
187 #endif
188     }
189     return ret;
190 }
191 
AdvanceScan(const WifiScanParams & params)192 ErrCode WifiScanServiceImpl::AdvanceScan(const WifiScanParams &params)
193 {
194     WIFI_LOGI("Scan with WifiScanParams, band %{public}u", params.band);
195 
196     if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
197         WIFI_LOGE("AdvanceScan:VerifySetWifiInfoPermission PERMISSION_DENIED!");
198         return WIFI_OPT_PERMISSION_DENIED;
199     }
200     if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
201         WIFI_LOGE("AdvanceScan:VerifyGetScanInfosPermission PERMISSION_DENIED!");
202         return WIFI_OPT_PERMISSION_DENIED;
203     }
204 
205     if (!IsScanServiceRunning()) {
206         return WIFI_OPT_SCAN_NOT_OPENED;
207     }
208 
209     bool externFlag = true;
210 #ifndef OHOS_ARCH_LITE
211     UpdateScanMode();
212     if (WifiAuthCenter::IsNativeProcess()) {
213         externFlag = false;
214         WIFI_LOGI("Scan: native process start scan !");
215     }
216 #endif
217     if (!IsWifiScanAllowed(externFlag)) {
218         WIFI_LOGE("Scan not allowed!");
219         return WIFI_OPT_FAILED;
220     }
221     IScanService *pService = WifiServiceManager::GetInstance().GetScanServiceInst(m_instId);
222     if (pService == nullptr) {
223         return WIFI_OPT_SCAN_NOT_OPENED;
224     }
225     return pService->ScanWithParam(params, externFlag);
226 }
227 
IsWifiScanAllowed(bool externFlag)228 bool WifiScanServiceImpl::IsWifiScanAllowed(bool externFlag)
229 {
230     WifiScanDeviceInfo scanInfo;
231     WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanDeviceInfo(scanInfo);
232     if (externFlag) {
233         if (WifiConfigCenter::GetInstance().GetWifiState(m_instId) != static_cast<int>(WifiState::ENABLED)) {
234             WIFI_LOGW("extern scan not allow when wifi disable");
235             return false;
236         }
237         if (scanInfo.idelState == MODE_STATE_OPEN) {
238             WIFI_LOGW("extern scan not allow by power idel state");
239             return false;
240         }
241     }
242     IEnhanceService *pEnhanceService = WifiServiceManager::GetInstance().GetEnhanceServiceInst();
243     if (pEnhanceService != nullptr) {
244         scanInfo.externScan = externFlag;
245         scanInfo.isSystemApp = WifiAuthCenter::IsSystemAccess();
246         bool allowScan = pEnhanceService->IsScanAllowed(scanInfo);
247         WifiConfigCenter::GetInstance().GetWifiScanConfig()->SaveScanDeviceInfo(scanInfo);
248         return allowScan;
249     }
250     return true;
251 }
252 
IsWifiClosedScan(bool & bOpen)253 ErrCode WifiScanServiceImpl::IsWifiClosedScan(bool &bOpen)
254 {
255     WIFI_LOGI("IsWifiClosedScan");
256     if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
257         WIFI_LOGE("IsWifiClosedScan:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
258         return WIFI_OPT_PERMISSION_DENIED;
259     }
260 
261     bOpen = WifiSettings::GetInstance().GetScanAlwaysState();
262     return WIFI_OPT_SUCCESS;
263 }
264 
GetScanInfoList(std::vector<WifiScanInfo> & result,bool compatible)265 ErrCode WifiScanServiceImpl::GetScanInfoList(std::vector<WifiScanInfo> &result, bool compatible)
266 {
267     WIFI_LOGI("GetScanInfoList, compatible:%{public}d", compatible);
268     int apiVersion = WifiPermissionUtils::GetApiVersion();
269     if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
270         WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
271         return WIFI_OPT_PERMISSION_DENIED;
272     }
273     if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
274         WIFI_LOGE("GetScanInfoList:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
275         return WIFI_OPT_PERMISSION_DENIED;
276     }
277     if (compatible) {
278         if ((WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) &&
279             (WifiPermissionUtils::VerifyGetWifiPeersMacPermission() == PERMISSION_DENIED)) {
280             WIFI_LOGE("GetScanInfoList:GET_WIFI_PEERS_MAC && LOCATION PERMISSION_DENIED!");
281             return WIFI_OPT_PERMISSION_DENIED;
282         }
283     }
284 
285     WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(result);
286     if (!compatible) {
287     #ifdef SUPPORT_RANDOM_MAC_ADDR
288         if (WifiPermissionUtils::VerifyGetWifiPeersMacPermission() == PERMISSION_DENIED) {
289             WIFI_LOGI("GetScanInfoList: GET_WIFI_PEERS_MAC PERMISSION_DENIED");
290             for (auto iter = result.begin(); iter != result.end(); ++iter) {
291                 WifiMacAddrInfo macAddrInfo;
292                 macAddrInfo.bssid = iter->bssid;
293                 macAddrInfo.bssidType = iter->bssidType;
294                 std::string randomMacAddr =
295                     WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO,
296                         macAddrInfo);
297                 WIFI_LOGD("ssid:%{private}s, bssid:%{private}s, bssidType:%{public}d, randomMacAddr:%{private}s",
298                     iter->ssid.c_str(), macAddrInfo.bssid.c_str(), macAddrInfo.bssidType, randomMacAddr.c_str());
299                 if (!randomMacAddr.empty() &&
300                     (macAddrInfo.bssidType == REAL_DEVICE_ADDRESS)) {
301                     iter->bssid = randomMacAddr;
302                     iter->bssidType = RANDOM_DEVICE_ADDRESS;
303                 }
304             }
305         }
306     #endif
307     }
308     return WIFI_OPT_SUCCESS;
309 }
310 
SetScanOnlyAvailable(bool bScanOnlyAvailable)311 ErrCode WifiScanServiceImpl::SetScanOnlyAvailable(bool bScanOnlyAvailable)
312 {
313     WIFI_LOGD("WifiScanServiceImpl::SetScanOnlyAvailable");
314     if (!WifiAuthCenter::IsSystemAccess()) {
315         WIFI_LOGE("SetScanOnlyAvailable:NOT System APP, PERMISSION_DENIED!");
316         return WIFI_OPT_NON_SYSTEMAPP;
317     }
318     if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
319         WIFI_LOGE("SetScanOnlyAvailable:VerifySetWifiInfoPermission() PERMISSION_DENIED!");
320         return WIFI_OPT_PERMISSION_DENIED;
321     }
322     if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
323         WIFI_LOGE("SetScanOnlyAvailable:VerifySetWifiConfigPermission() PERMISSION_DENIED!");
324         return WIFI_OPT_PERMISSION_DENIED;
325     }
326     WifiSettings::GetInstance().SetScanOnlySwitchState(bScanOnlyAvailable, m_instId);
327     ErrCode errCode = WIFI_OPT_SUCCESS;
328     if (bScanOnlyAvailable) {
329         errCode = WifiManager::GetInstance().GetWifiTogglerManager()->ScanOnlyToggled(1);
330     } else {
331         errCode = WifiManager::GetInstance().GetWifiTogglerManager()->ScanOnlyToggled(0);
332     }
333     return errCode;
334 }
335 
GetScanOnlyAvailable(bool & bScanOnlyAvailable)336 ErrCode WifiScanServiceImpl::GetScanOnlyAvailable(bool &bScanOnlyAvailable)
337 {
338     WIFI_LOGD("WifiScanServiceImpl::GetScanOnlyAvailable");
339     if (!WifiAuthCenter::IsSystemAccess()) {
340         WIFI_LOGE("GetScanOnlyAvailable: NOT System APP, PERMISSION_DENIED!");
341         return WIFI_OPT_NON_SYSTEMAPP;
342     }
343     if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
344         WIFI_LOGE("GetScanOnlyAvailable:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
345         return WIFI_OPT_PERMISSION_DENIED;
346     }
347     if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
348         WIFI_LOGE("GetScanOnlyAvailable:VerifyGetWifiConfigPermission() PERMISSION_DENIED!");
349         return WIFI_OPT_PERMISSION_DENIED;
350     }
351 
352     bScanOnlyAvailable = WifiSettings::GetInstance().GetScanOnlySwitchState(m_instId);
353     return WIFI_OPT_SUCCESS;
354 }
355 
StartWifiPnoScan(bool isStartAction,int periodMs,int suspendReason)356 ErrCode WifiScanServiceImpl::StartWifiPnoScan(bool isStartAction, int periodMs, int suspendReason)
357 {
358     WIFI_LOGD("WifiScanServiceImpl::StartWifiPnoScan");
359     if (!WifiAuthCenter::IsSystemAccess()) {
360         WIFI_LOGE("StartWifiPnoScan:NOT System APP, PERMISSION_DENIED!");
361         return WIFI_OPT_NON_SYSTEMAPP;
362     }
363 
364     if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
365         WIFI_LOGE("StartWifiPnoScan:VerifySetWifiInfoPermission PERMISSION_DENIED!");
366         return WIFI_OPT_PERMISSION_DENIED;
367     }
368     if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
369         WIFI_LOGE("StartWifiPnoScan:VerifyWifiConnectionPermission PERMISSION_DENIED!");
370         return WIFI_OPT_PERMISSION_DENIED;
371     }
372     IScanService *pService = WifiServiceManager::GetInstance().GetScanServiceInst(m_instId);
373     if (pService == nullptr) {
374         return WIFI_OPT_SCAN_NOT_OPENED;
375     }
376     return pService->StartWifiPnoScan(isStartAction, periodMs, suspendReason);
377 }
378 
379 #ifdef OHOS_ARCH_LITE
RegisterCallBack(const std::shared_ptr<IWifiScanCallback> & callback,const std::vector<std::string> & event)380 ErrCode WifiScanServiceImpl::RegisterCallBack(const std::shared_ptr<IWifiScanCallback> &callback,
381     const std::vector<std::string> &event)
382 #else
383 ErrCode WifiScanServiceImpl::RegisterCallBack(const sptr<IWifiScanCallback> &callback,
384     const std::vector<std::string> &event)
385 #endif
386 {
387     WIFI_LOGI("WifiScanServiceImpl::RegisterCallBack!");
388     for (const auto &eventName : event) {
389         WifiInternalEventDispatcher::GetInstance().SetSingleScanCallback(callback, eventName, m_instId);
390     }
391     return WIFI_OPT_SUCCESS;
392 }
393 
GetSupportedFeatures(long & features)394 ErrCode WifiScanServiceImpl::GetSupportedFeatures(long &features)
395 {
396     if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
397         WIFI_LOGE("GetSupportedFeatures:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
398         return WIFI_OPT_PERMISSION_DENIED;
399     }
400     int ret = WifiManager::GetInstance().GetSupportedFeatures(features);
401     if (ret < 0) {
402         WIFI_LOGE("Failed to get supported features!");
403         return WIFI_OPT_FAILED;
404     }
405     return WIFI_OPT_SUCCESS;
406 }
407 
IsScanServiceRunning()408 bool WifiScanServiceImpl::IsScanServiceRunning()
409 {
410     WifiOprMidState curState = WifiConfigCenter::GetInstance().GetScanMidState(m_instId);
411     if (curState != WifiOprMidState::RUNNING) {
412         WIFI_LOGW("scan service does not started!");
413         return false;
414     }
415     return true;
416 }
417 
SaBasicDump(std::string & result)418 void WifiScanServiceImpl::SaBasicDump(std::string& result)
419 {
420     WifiScanServiceImpl impl;
421     bool isRunning = impl.IsScanServiceRunning();
422     result.append("Is scan service running: ");
423     std::string strRunning = isRunning ? "true" : "false";
424     result += strRunning + "\n";
425 }
426 
IsRemoteDied(void)427 bool WifiScanServiceImpl::IsRemoteDied(void)
428 {
429     return false;
430 }
431 
432 #ifndef OHOS_ARCH_LITE
UpdateScanMode()433 void WifiScanServiceImpl::UpdateScanMode()
434 {
435     int uid = GetCallingUid();
436     std::string packageName = "";
437     GetBundleNameByUid(uid, packageName);
438     if (WifiAppStateAware::GetInstance().IsForegroundApp(uid)
439         || packageName == WifiSettings::GetInstance().GetVariablePackageName("SETTINGS")) {
440         WifiConfigCenter::GetInstance().GetWifiScanConfig()->SetAppRunningState(ScanMode::APP_FOREGROUND_SCAN);
441     } else {
442         WifiConfigCenter::GetInstance().GetWifiScanConfig()->SetAppRunningState(ScanMode::APP_BACKGROUND_SCAN);
443     }
444 }
445 #endif
446 }  // namespace Wifi
447 }  // namespace OHOS
448