1 /*
2 * Copyright (C) 2021-2025 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_device_service_impl.h"
17 #include <algorithm>
18 #include <chrono>
19 #include <unistd.h>
20 #include "wifi_permission_utils.h"
21 #include "wifi_internal_msg.h"
22 #include "wifi_auth_center.h"
23 #include "wifi_channel_helper.h"
24 #include "wifi_config_center.h"
25 #ifdef OHOS_ARCH_LITE
26 #include "wifi_internal_event_dispatcher_lite.h"
27 #else
28 #include "wifi_internal_event_dispatcher.h"
29 #include "wifi_sa_manager.h"
30 #include "mac_address.h"
31 #include "wifi_p2p_service_impl.h"
32 #include "wifi_country_code_manager.h"
33 #include "app_network_speed_limit_service.h"
34 #include "wifi_history_record_manager.h"
35 #endif
36 #include "wifi_manager.h"
37 #include "wifi_service_manager.h"
38 #include "wifi_protect_manager.h"
39 #include "wifi_logger.h"
40 #include "define.h"
41 #include "wifi_common_util.h"
42 #include "wifi_protect_manager.h"
43 #include "wifi_global_func.h"
44 #include "wifi_sta_hal_interface.h"
45 #include "wifi_randommac_helper.h"
46 #include "wifi_sta_hal_interface.h"
47 #include "block_connect_service.h"
48
49 DEFINE_WIFILOG_LABEL("WifiDeviceServiceImpl");
50 namespace OHOS {
51 namespace Wifi {
52
53 constexpr const char *BROKER_PROCESS_PROTECT_FLAG = "register_process_info";
54 constexpr int WIFI_BROKER_NETWORK_ID = -2;
55 constexpr int EXTENSION_ERROR_CODE = 13500099;
56 constexpr int RSS_UID = 1096;
57
58 bool g_hiLinkActive = false;
59 constexpr int HILINK_CMD_MAX_LEN = 1024;
60 #ifdef FEATURE_WIFI_MDM_RESTRICTED_SUPPORT
61 constexpr const int MAX_MDM_RESTRICTED_SIZE = 200;
62 #endif
63
64 #ifdef OHOS_ARCH_LITE
65 std::mutex WifiDeviceServiceImpl::g_instanceLock;
66 std::shared_ptr<WifiDeviceServiceImpl> WifiDeviceServiceImpl::g_instance = nullptr;
GetInstance()67 std::shared_ptr<WifiDeviceServiceImpl> WifiDeviceServiceImpl::GetInstance()
68 {
69 if (g_instance == nullptr) {
70 std::lock_guard<std::mutex> autoLock(g_instanceLock);
71 if (g_instance == nullptr) {
72 std::shared_ptr<WifiDeviceServiceImpl> service = std::make_shared<WifiDeviceServiceImpl>();
73 g_instance = service;
74 }
75 }
76 return g_instance;
77 }
78
OnStart()79 void WifiDeviceServiceImpl::OnStart()
80 {
81 if (mState == ServiceRunningState::STATE_RUNNING) {
82 WIFI_LOGW("Service has already started.");
83 return;
84 }
85
86 WifiManager::GetInstance();
87 mState = ServiceRunningState::STATE_RUNNING;
88 WIFI_LOGI("Start sta service!");
89 }
90
OnStop()91 void WifiDeviceServiceImpl::OnStop()
92 {
93 mState = ServiceRunningState::STATE_NOT_START;
94 WIFI_LOGI("Stop sta service!");
95 }
96 #endif
97
98
WifiDeviceServiceImpl()99 WifiDeviceServiceImpl::WifiDeviceServiceImpl()
100 #ifdef OHOS_ARCH_LITE
101 : mState(ServiceRunningState::STATE_NOT_START)
102 #endif
103 {
104 WIFI_LOGI("enter WifiDeviceServiceImpl");
105 }
106
107 #ifndef OHOS_ARCH_LITE
WifiDeviceServiceImpl(int instId)108 WifiDeviceServiceImpl::WifiDeviceServiceImpl(int instId) : WifiDeviceStub(instId)
109 {
110 WIFI_LOGI("enter WifiDeviceServiceImpl");
111 }
112 #endif
113
~WifiDeviceServiceImpl()114 WifiDeviceServiceImpl::~WifiDeviceServiceImpl()
115 {
116 WIFI_LOGI("enter ~WifiDeviceServiceImpl");
117 }
118
EnableWifi()119 ErrCode WifiDeviceServiceImpl::EnableWifi()
120 {
121 #ifndef OHOS_ARCH_LITE
122 WIFI_LOGI("EnableWifi(), pid:%{public}d, uid:%{public}d, BundleName:%{public}s.",
123 GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
124 #endif
125 ErrCode errCode = CheckCanEnableWifi();
126 if (errCode != WIFI_OPT_SUCCESS) {
127 return errCode;
128 }
129
130 if (m_instId == INSTID_WLAN0) {
131 WifiConfigCenter::GetInstance().SetWifiToggledState(WIFI_STATE_ENABLED);
132 #ifndef OHOS_ARCH_LITE
133 WifiSettings::GetInstance().SetWifiToggleCaller(GetCallingPid(), m_instId);
134 #endif
135 WifiManager::GetInstance().GetWifiTogglerManager()->StartWifiToggledTimer();
136 WifiManager::GetInstance().GetWifiTogglerManager()->StopSemiWifiToggledTimer();
137 }
138 return WifiManager::GetInstance().GetWifiTogglerManager()->WifiToggled(1, m_instId);
139 }
140
DisableWifi()141 ErrCode WifiDeviceServiceImpl::DisableWifi()
142 {
143 #ifndef OHOS_ARCH_LITE
144 WIFI_LOGI("DisableWifi(), pid:%{public}d, uid:%{public}d, BundleName:%{public}s.",
145 GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
146 #endif
147 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
148 WIFI_LOGE("DisableWifi:VerifySetWifiInfoPermission PERMISSION_DENIED!");
149 return WIFI_OPT_PERMISSION_DENIED;
150 }
151
152 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED &&
153 WifiPermissionUtils::VerifyEnterpriseWifiConnectionPermission() == PERMISSION_DENIED) {
154 WIFI_LOGE("DisableWifi:VerifyWifiConnectionPermission PERMISSION_DENIED!");
155 return WIFI_OPT_PERMISSION_DENIED;
156 }
157
158 if (m_instId == INSTID_WLAN0 && IsDisableWifiProhibitedByEdm()) {
159 WIFI_LOGE("DisableWifi:wifi is prohibited by EDM!");
160 return WIFI_OPT_FAILED;
161 }
162
163 if (m_instId == INSTID_WLAN0 || m_instId == INSTID_WLAN1) {
164 WifiConfigCenter::GetInstance().SetWifiToggledState(WIFI_STATE_DISABLED, m_instId);
165 WifiConfigCenter::GetInstance().SetWifiAllowSemiActive(false);
166 #ifndef OHOS_ARCH_LITE
167 WifiSettings::GetInstance().SetWifiToggleCaller(GetCallingPid(), m_instId);
168 #endif
169 }
170
171 if (m_instId == INSTID_WLAN0) {
172 WifiManager::GetInstance().GetWifiTogglerManager()->StopWifiToggledTimer();
173 WifiManager::GetInstance().GetWifiTogglerManager()->StopSemiWifiToggledTimer();
174 }
175 return WifiManager::GetInstance().GetWifiTogglerManager()->WifiToggled(0, m_instId);
176 }
177
EnableSemiWifi()178 ErrCode WifiDeviceServiceImpl::EnableSemiWifi()
179 {
180 #ifndef OHOS_ARCH_LITE
181 WIFI_LOGI("EnableSemiWifi(), pid:%{public}d, uid:%{public}d, BundleName:%{public}s.",
182 GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
183 #endif
184 if (!WifiAuthCenter::IsSystemAccess()) {
185 WIFI_LOGE("EnableSemiWifi: NOT System APP, PERMISSION_DENIED!");
186 return WIFI_OPT_NON_SYSTEMAPP;
187 }
188 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
189 WIFI_LOGE("EnableSemiWifi:VerifySetWifiInfoPermission PERMISSION_DENIED!");
190 return WIFI_OPT_PERMISSION_DENIED;
191 }
192
193 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
194 WIFI_LOGE("EnableSemiWifi:VerifyWifiConnectionPermission PERMISSION_DENIED!");
195 return WIFI_OPT_PERMISSION_DENIED;
196 }
197 #ifndef OHOS_ARCH_LITE
198 if (WifiManager::GetInstance().GetWifiEventSubscriberManager()->IsMdmForbidden()) {
199 WIFI_LOGE("EnableSemiWifi: Mdm forbidden PERMISSION_DENIED!");
200 return WIFI_OPT_ENTERPRISE_DENIED;
201 }
202 if (WifiManager::GetInstance().GetWifiTogglerManager()->IsSatelliteStateStart()) {
203 WIFI_LOGI("current satellite mode and can not use sta, open failed!");
204 return WIFI_OPT_FORBID_AIRPLANE;
205 }
206 #endif
207 if (m_instId == INSTID_WLAN0 || m_instId == INSTID_WLAN1) {
208 WifiConfigCenter::GetInstance().SetWifiToggledState(WIFI_STATE_SEMI_ENABLED);
209 #ifndef OHOS_ARCH_LITE
210 WifiSettings::GetInstance().SetWifiToggleCaller(GetCallingPid(), m_instId);
211 #endif
212 }
213
214 if (m_instId == INSTID_WLAN0) {
215 WifiManager::GetInstance().GetWifiTogglerManager()->StopWifiToggledTimer();
216 WifiManager::GetInstance().GetWifiTogglerManager()->StartSemiWifiToggledTimer();
217 }
218 return WifiManager::GetInstance().GetWifiTogglerManager()->WifiToggled(0, m_instId);
219 }
220
InitWifiProtect(const WifiProtectType & protectType,const std::string & protectName)221 ErrCode WifiDeviceServiceImpl::InitWifiProtect(const WifiProtectType &protectType, const std::string &protectName)
222 {
223 /* refer to WifiProtectManager::GetInstance().InitWifiProtect, DO NOT support now! */
224 return WIFI_OPT_SUCCESS;
225 }
226
IsHeldWifiProtectRef(const std::string & protectName,bool & isHoldProtect)227 ErrCode WifiDeviceServiceImpl::IsHeldWifiProtectRef(
228 const std::string &protectName, bool &isHoldProtect)
229 {
230 #ifdef OHOS_ARCH_LITE
231 /* refer to WifiProtectManager::GetInstance().IsHeldWifiProtect, DO NOT support now! */
232 return WIFI_OPT_SUCCESS;
233 #else
234 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
235 WIFI_LOGE("IsHeldWifiProtectRef:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
236 return WIFI_OPT_PERMISSION_DENIED;
237 }
238 isHoldProtect = WifiProtectManager::GetInstance().IsHeldWifiProtect(protectName);
239 WIFI_LOGD("App %{public}s hold protect is %{public}d", protectName.c_str(), isHoldProtect);
240 return WIFI_OPT_SUCCESS;
241 #endif
242 }
243
GetWifiProtectRef(const WifiProtectMode & protectMode,const std::string & protectName)244 ErrCode WifiDeviceServiceImpl::GetWifiProtectRef(const WifiProtectMode &protectMode, const std::string &protectName)
245 {
246 #ifdef OHOS_ARCH_LITE
247 /* refer to WifiProtectManager::GetInstance().GetWifiProtect, DO NOT support now! */
248 return WIFI_OPT_SUCCESS;
249 #else
250 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
251 WIFI_LOGE("GetWifiProtectRef:VerifySetWifiInfoPermission PERMISSION_DENIED!");
252 return WIFI_OPT_PERMISSION_DENIED;
253 }
254 if (!WifiProtectManager::GetInstance().GetWifiProtect(protectMode, protectName)) {
255 WIFI_LOGE("App %{public}s set protect mode %{public}d failed.",
256 protectName.c_str(), static_cast<int>(protectMode));
257 return WIFI_OPT_FAILED;
258 }
259 return WIFI_OPT_SUCCESS;
260 #endif
261 }
262
PutWifiProtectRef(const std::string & protectName)263 ErrCode WifiDeviceServiceImpl::PutWifiProtectRef(const std::string &protectName)
264 {
265 #ifdef OHOS_ARCH_LITE
266 /* refer to WifiProtectManager::GetInstance().PutWifiProtect, DO NOT support now! */
267 return WIFI_OPT_SUCCESS;
268 #else
269 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
270 WIFI_LOGE("PutWifiProtectRef:VerifySetWifiInfoPermission PERMISSION_DENIED!");
271 return WIFI_OPT_PERMISSION_DENIED;
272 }
273 if (!WifiProtectManager::GetInstance().PutWifiProtect(protectName)) {
274 WIFI_LOGE("App %{public}s remove protect mode failed.", protectName.c_str());
275 return WIFI_OPT_FAILED;
276 }
277 return WIFI_OPT_SUCCESS;
278 #endif
279 }
280
CheckConfigEap(const WifiDeviceConfig & config)281 bool WifiDeviceServiceImpl::CheckConfigEap(const WifiDeviceConfig &config)
282 {
283 if (config.keyMgmt != KEY_MGMT_EAP && config.keyMgmt != KEY_MGMT_SUITE_B_192) {
284 WIFI_LOGE("CheckConfigEap: keyMgmt is not EAP!");
285 return false;
286 }
287 if (config.wifiEapConfig.eap == EAP_METHOD_TLS) {
288 if (config.wifiEapConfig.identity.empty() ||
289 (config.wifiEapConfig.certEntry.size() == 0 &&
290 (config.wifiEapConfig.clientCert.empty() ||
291 config.wifiEapConfig.privateKey.empty()))) {
292 WIFI_LOGE("CheckConfigEap: with invalid TLS params!");
293 return false;
294 }
295 return true;
296 } else if ((config.wifiEapConfig.eap == EAP_METHOD_PEAP) || (config.wifiEapConfig.eap == EAP_METHOD_PWD) ||
297 (config.wifiEapConfig.eap == EAP_METHOD_TTLS)) {
298 if (config.wifiEapConfig.identity.empty() || config.wifiEapConfig.password.empty()) {
299 WIFI_LOGE("CheckConfigEap: invalid parameter, the identity length is:%{public}zu",
300 config.wifiEapConfig.identity.length());
301 return false;
302 }
303 return true;
304 } else {
305 WIFI_LOGW("EAP:%{public}s unsupported!", config.wifiEapConfig.eap.c_str());
306 }
307 return true;
308 }
309
CheckConfigWapi(const WifiDeviceConfig & config)310 bool WifiDeviceServiceImpl::CheckConfigWapi(const WifiDeviceConfig &config)
311 {
312 if (config.keyMgmt == KEY_MGMT_WAPI_PSK) {
313 if (config.wifiWapiConfig.wapiPskType < static_cast<int>(WapiPskType::WAPI_PSK_ASCII) ||
314 config.wifiWapiConfig.wapiPskType > static_cast<int>(WapiPskType::WAPI_PSK_HEX)) {
315 WIFI_LOGE("CheckConfigWapi: with invalid wapiPskType!");
316 return false;
317 }
318 return true;
319 }
320
321 if (config.wifiWapiConfig.wapiAsCertData.empty() || config.wifiWapiConfig.wapiUserCertData.empty()) {
322 WIFI_LOGE("CheckConfigWapi: with cert data empty!");
323 return false;
324 }
325
326 return true;
327 }
328
CheckOriSsidLength(const WifiDeviceConfig & config)329 static bool CheckOriSsidLength(const WifiDeviceConfig &config)
330 {
331 std::vector<WifiScanInfo> scanInfoList;
332 WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(scanInfoList);
333 std::string deviceKeyMgmt = "";
334 for (auto &scanInfo : scanInfoList) {
335 scanInfo.GetDeviceMgmt(deviceKeyMgmt);
336 // Hybrid encryption currently only supports WPA-PSK+SAE, which is treated specially here
337 if (config.ssid == scanInfo.ssid
338 && ((deviceKeyMgmt == "WPA-PSK+SAE" && deviceKeyMgmt.find(config.keyMgmt) != std::string::npos)
339 || (config.keyMgmt == deviceKeyMgmt))) {
340 LOGI("CheckOriSsidLength: oriSsid length:%{public}zu", scanInfo.oriSsid.length());
341 if ((scanInfo.oriSsid.length() > 0) && (scanInfo.oriSsid.length() <= DEVICE_NAME_LENGTH)) {
342 return true;
343 }
344 break;
345 }
346 }
347 return false;
348 }
349
CheckConfigPwd(const WifiDeviceConfig & config)350 bool WifiDeviceServiceImpl::CheckConfigPwd(const WifiDeviceConfig &config)
351 {
352 if (config.ssid.length() <= 0 || (config.keyMgmt.length()) <= 0) {
353 WIFI_LOGE("CheckConfigPwd: invalid ssid or keyMgmt!");
354 return false;
355 }
356 if (config.ssid.length() > DEVICE_NAME_LENGTH) {
357 if (!CheckOriSsidLength(config)) {
358 LOGE("CheckConfigPwd: invalid ssid");
359 return false;
360 }
361 }
362 WIFI_LOGI("CheckConfigPwd: keyMgmt = %{public}s!", config.keyMgmt.c_str());
363 if (config.keyMgmt == KEY_MGMT_EAP || config.keyMgmt == KEY_MGMT_SUITE_B_192) {
364 return CheckConfigEap(config);
365 }
366
367 if (config.keyMgmt == KEY_MGMT_WAPI_CERT || config.keyMgmt == KEY_MGMT_WAPI_PSK) {
368 return CheckConfigWapi(config);
369 }
370
371 if (config.keyMgmt == KEY_MGMT_NONE) {
372 return config.preSharedKey.empty();
373 }
374
375 if (config.keyMgmt != KEY_MGMT_WEP && config.preSharedKey.empty()) {
376 WIFI_LOGE("CheckConfigPwd: preSharedKey is empty!");
377 return false;
378 }
379
380 int len = static_cast<int>(config.preSharedKey.length());
381 bool isAllHex = std::all_of(config.preSharedKey.begin(), config.preSharedKey.end(), isxdigit);
382 WIFI_LOGI("CheckConfigPwd, ssid: %{public}s, psk len: %{public}d", SsidAnonymize(config.ssid).c_str(), len);
383 if (config.keyMgmt == KEY_MGMT_WEP) {
384 for (int i = 0; i != WEPKEYS_SIZE; ++i) {
385 if (!config.wepKeys[i].empty()) { // wep
386 uint32_t wepLen = config.wepKeys[i].size();
387 if (wepLen == WEP_KEY_LEN1 || wepLen == WEP_KEY_LEN2 || wepLen == WEP_KEY_LEN3) {
388 return true;
389 }
390 constexpr int MULTIPLE_HEXT_TO_ASCII = 2;
391 if (wepLen == (WEP_KEY_LEN1 * MULTIPLE_HEXT_TO_ASCII) ||
392 wepLen == (WEP_KEY_LEN2 * MULTIPLE_HEXT_TO_ASCII) ||
393 wepLen == (WEP_KEY_LEN3 * MULTIPLE_HEXT_TO_ASCII)) {
394 return isAllHex;
395 }
396 WIFI_LOGE("CheckConfigPwd: invalid wepLen: %{public}d!", wepLen);
397 return false;
398 }
399 }
400 return true;
401 }
402 int minLen = config.keyMgmt == KEY_MGMT_SAE ? MIN_SAE_LEN : MIN_PSK_LEN;
403 int maxLen = isAllHex ? MAX_HEX_LEN : MAX_PRESHAREDKEY_LEN;
404 if (len < minLen || len > maxLen) {
405 WIFI_LOGE("CheckConfigPwd: preSharedKey length error: %{public}d", len);
406 return false;
407 }
408 return true;
409 }
410
411 #ifndef OHOS_ARCH_LITE
InitWifiBrokerProcessInfo(const WifiDeviceConfig & config)412 bool WifiDeviceServiceImpl::InitWifiBrokerProcessInfo(const WifiDeviceConfig &config)
413 {
414 WIFI_LOGD("InitWifiBrokerProcessInfo,networkId=%{public}d, ProcessName=[%{public}s],"
415 "ancoCallProcessName =[%{public}s],bssid = [%{public}s],ssid=[%{public}s]",
416 config.networkId, config.callProcessName.c_str(), config.ancoCallProcessName.c_str(),
417 MacAnonymize(config.bssid).c_str(), SsidAnonymize(config.ssid).c_str());
418 if (config.networkId != WIFI_BROKER_NETWORK_ID || config.ancoCallProcessName != BROKER_PROCESS_PROTECT_FLAG ||
419 !config.bssid.empty() || !config.ssid.empty()) {
420 return false;
421 }
422 auto ancoWifiValue = WifiSettings::GetInstance().GetPackageName("anco_broker_name");
423 if (!ancoWifiValue.empty() && config.callProcessName == ancoWifiValue) {
424 SetWifiBrokerProcess(GetCallingPid(), config.callProcessName);
425 return true;
426 }
427 return false;
428 }
429 #endif
430
CheckCallingUid(int & uid)431 ErrCode WifiDeviceServiceImpl::CheckCallingUid(int &uid)
432 {
433 #ifndef OHOS_ARCH_LITE
434 uid = GetCallingUid();
435 if (!WifiAppStateAware::GetInstance().IsForegroundApp(uid)) {
436 return WIFI_OPT_INVALID_PARAM;
437 }
438 return WIFI_OPT_SUCCESS;
439 #else
440 return WIFI_OPT_NOT_SUPPORTED;
441 #endif
442 }
443
IsWifiBrokerProcess(int uid)444 bool WifiDeviceServiceImpl::IsWifiBrokerProcess(int uid)
445 {
446 #ifndef OHOS_ARCH_LITE
447 int pid = GetCallingPid();
448 auto wifiBrokerFrameProcessName = WifiSettings::GetInstance().GetPackageName("anco_broker_name");
449 std::string ancoBrokerFrameProcessName = GetBrokerProcessNameByPid(uid, pid);
450 if (wifiBrokerFrameProcessName.empty() || ancoBrokerFrameProcessName != wifiBrokerFrameProcessName) {
451 return false;
452 }
453 return true;
454 #else
455 return false;
456 #endif
457 }
458
CheckRemoveCandidateConfig(void)459 ErrCode WifiDeviceServiceImpl::CheckRemoveCandidateConfig(void)
460 {
461 int apiVersion = WifiPermissionUtils::GetApiVersion();
462 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
463 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
464 return WIFI_OPT_PERMISSION_DENIED;
465 }
466 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
467 WIFI_LOGE("CheckRemoveCandidateConfig:VerifySetWifiInfoPermission PERMISSION_DENIED!");
468 return WIFI_OPT_PERMISSION_DENIED;
469 }
470
471 if (!IsStaServiceRunning()) {
472 WIFI_LOGE("CheckRemoveCandidateConfig:IsStaServiceRunning not running!");
473 return WIFI_OPT_STA_NOT_OPENED;
474 }
475
476 return WIFI_OPT_SUCCESS;
477 }
478
SetWifiConnectedMode(void)479 void WifiDeviceServiceImpl::SetWifiConnectedMode(void)
480 {
481 #ifndef OHOS_ARCH_LITE
482 if (IsWifiBrokerProcess(GetCallingUid())) {
483 WifiConfigCenter::GetInstance().SetWifiConnectedMode(true, m_instId);
484 WIFI_LOGD("WifiDeviceServiceImpl %{public}s, anco, %{public}d", __func__, m_instId);
485 } else {
486 WifiConfigCenter::GetInstance().SetWifiConnectedMode(false, m_instId);
487 WIFI_LOGD("WifiDeviceServiceImpl %{public}s, not anco, %{public}d", __func__, m_instId);
488 }
489 #endif
490 return;
491 }
RemoveCandidateConfig(const WifiDeviceConfig & config)492 ErrCode WifiDeviceServiceImpl::RemoveCandidateConfig(const WifiDeviceConfig &config)
493 {
494 ErrCode ret = CheckRemoveCandidateConfig();
495 if (ret != WIFI_OPT_SUCCESS) {
496 return ret;
497 }
498 /* check the caller's uid */
499 int uid = 0;
500 if (CheckCallingUid(uid) != WIFI_OPT_SUCCESS) {
501 if (!IsWifiBrokerProcess(uid)) {
502 WIFI_LOGE("CheckCallingUid IsWifiBrokerProcess failed!");
503 return WIFI_OPT_INVALID_PARAM;
504 }
505 }
506 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
507 if (pService == nullptr) {
508 WIFI_LOGE("pService is nullptr!");
509 return WIFI_OPT_STA_NOT_OPENED;
510 }
511 /* get all candidate configs */
512 std::vector<WifiDeviceConfig> configs;
513 if (WifiSettings::GetInstance().GetAllCandidateConfig(uid, configs) != 0) {
514 WIFI_LOGE("NOT find the caller's configs!");
515 return WIFI_OPT_INVALID_CONFIG;
516 }
517 /* find the networkId of the removed config */
518 int networkId = INVALID_NETWORK_ID;
519 size_t size = configs.size();
520 for (size_t i = 0; i < size; i++) {
521 if (configs[i].ssid == config.ssid) {
522 networkId = configs[i].networkId;
523 WIFI_LOGI("find the removed config, networkId:%{public}d!", networkId);
524 break;
525 }
526 }
527 /* removed the config */
528 if (networkId != INVALID_NETWORK_ID) {
529 return pService->RemoveCandidateConfig(uid, networkId);
530 }
531 return WIFI_OPT_INVALID_CONFIG;
532 }
533
RemoveCandidateConfig(int networkId)534 ErrCode WifiDeviceServiceImpl::RemoveCandidateConfig(int networkId)
535 {
536 ErrCode ret = CheckRemoveCandidateConfig();
537 if (ret != WIFI_OPT_SUCCESS) {
538 return ret;
539 }
540 int uid = 0;
541 if (CheckCallingUid(uid) != WIFI_OPT_SUCCESS) {
542 if (!IsWifiBrokerProcess(uid)) {
543 WIFI_LOGE("IsWifiBrokerProcess failed!");
544 return WIFI_OPT_INVALID_PARAM;
545 }
546 }
547 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
548 if (pService == nullptr) {
549 WIFI_LOGE("pService is nullptr!");
550 return WIFI_OPT_STA_NOT_OPENED;
551 }
552 if (networkId == INVALID_NETWORK_ID) {
553 return pService->RemoveAllCandidateConfig(uid);
554 } else {
555 return pService->RemoveCandidateConfig(uid, networkId);
556 }
557 }
558
updateStaDeviceMacAddress(WifiDeviceConfig & config)559 void WifiDeviceServiceImpl::updateStaDeviceMacAddress(WifiDeviceConfig &config)
560 {
561 WifiMacAddrInfo macAddrInfo;
562 macAddrInfo.bssid = config.bssid;
563 macAddrInfo.bssidType = config.bssidType;
564 std::string macAddr =
565 WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO,
566 macAddrInfo);
567 if (macAddr.empty()) {
568 WIFI_LOGW("%{public}s: record not found, bssid:%{private}s, bssidType:%{public}d",
569 __func__, config.bssid.c_str(), config.bssidType);
570 } else {
571 WIFI_LOGI("%{public}s: the record is exists, bssid:%{private}s, bssidType:%{public}d, randomMac:%{private}s",
572 __func__, config.bssid.c_str(), config.bssidType, macAddr.c_str());
573 /* random MAC address are translated into real MAC address */
574 if (!config.bssid.empty() && config.bssidType == RANDOM_DEVICE_ADDRESS) {
575 config.bssid = macAddr;
576 config.bssidType = REAL_DEVICE_ADDRESS;
577 WIFI_LOGI("%{public}s: the record is updated, bssid:%{private}s, bssidType:%{public}d",
578 __func__, config.bssid.c_str(), config.bssidType);
579 }
580 }
581 }
582
AddDeviceConfig(const WifiDeviceConfig & config,int & result,bool isCandidate)583 ErrCode WifiDeviceServiceImpl::AddDeviceConfig(const WifiDeviceConfig &config, int &result, bool isCandidate)
584 {
585 ErrCode errCode = CheckCanAddDeviceConfig(isCandidate);
586 if (errCode != WIFI_OPT_SUCCESS) {
587 return errCode;
588 }
589 #ifndef OHOS_ARCH_LITE
590 if (InitWifiBrokerProcessInfo(config)) {
591 return WIFI_OPT_SUCCESS;
592 }
593 #endif
594 if (!CheckConfigPwd(config)) {
595 WIFI_LOGE("CheckConfigPwd failed!");
596 return WIFI_OPT_INVALID_PARAM;
597 }
598
599 if (isCandidate && config.bssid.length() != 0 && CheckMacIsValid(config.bssid) != 0) {
600 WIFI_LOGE("AddDeviceConfig:VerifyBSSID failed!");
601 return WIFI_OPT_INVALID_PARAM;
602 }
603
604 if (!IsStaServiceRunning()) {
605 return WIFI_OPT_STA_NOT_OPENED;
606 }
607 WifiDeviceConfig updateConfig = config;
608 #ifdef SUPPORT_RANDOM_MAC_ADDR
609 updateStaDeviceMacAddress(updateConfig);
610 #endif
611 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
612 if (pService == nullptr) {
613 return WIFI_OPT_STA_NOT_OPENED;
614 }
615
616 if (isCandidate) {
617 int uid = 0;
618 if (CheckCallingUid(uid) != WIFI_OPT_SUCCESS) {
619 if (!IsWifiBrokerProcess(uid)) {
620 WIFI_LOGE("CheckCallingUid IsWifiBrokerProcess failed!");
621 return WIFI_OPT_INVALID_PARAM;
622 }
623 }
624 if (!IsWifiBrokerProcess(uid)) {
625 updateConfig.isEphemeral = true;
626 }
627 return pService->AddCandidateConfig(uid, updateConfig, result);
628 }
629
630 int retNetworkId = pService->AddDeviceConfig(updateConfig);
631 if (retNetworkId < 0) {
632 return WIFI_OPT_FAILED;
633 }
634 result = retNetworkId;
635 return WIFI_OPT_SUCCESS;
636 }
637
SetWifiRestrictedList(const std::vector<WifiRestrictedInfo> & wifiRestrictedInfoList)638 ErrCode WifiDeviceServiceImpl::SetWifiRestrictedList(const std::vector<WifiRestrictedInfo> &wifiRestrictedInfoList)
639 {
640 #ifdef FEATURE_WIFI_MDM_RESTRICTED_SUPPORT
641 if (WifiPermissionUtils::VerifyManageEdmPolicyPermission() == PERMISSION_DENIED) {
642 WIFI_LOGE("SetWifiRestrictedList:VerifyManageEdmPolicyPermission PERMISSION_DENIED!");
643 return WIFI_OPT_PERMISSION_DENIED;
644 }
645 std::vector<WifiRestrictedInfo> tmp;
646 tmp.assign(wifiRestrictedInfoList.begin(), wifiRestrictedInfoList.end());
647 ErrCode checkResult = WifiSettings::GetInstance().CheckWifiMdmRestrictedList(tmp);
648 if (checkResult != WIFI_OPT_SUCCESS) {
649 return checkResult;
650 }
651 BlockConnectService::GetInstance().ClearBlockConnectForMdmRestrictedList();
652 WifiSettings::GetInstance().ClearWifiRestrictedListConfig(m_instId);
653 for (size_t i = 0; i < tmp.size() && i <= MAX_MDM_RESTRICTED_SIZE; i++) {
654 WifiSettings::GetInstance().AddWifiRestrictedListConfig(m_instId, tmp[i]);
655 }
656 WifiSettings::GetInstance().SyncWifiRestrictedListConfig();
657 BlockConnectService::GetInstance().UpdateNetworkSelectStatusForMdmRestrictedList();
658 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
659 if (pService == nullptr) {
660 return WIFI_OPT_SUCCESS;
661 }
662 return pService->SetWifiRestrictedList(wifiRestrictedInfoList);
663 #else
664 return WIFI_OPT_FAILED;
665 #endif
666 }
667
CheckCanAddDeviceConfig(const bool isCandidate)668 ErrCode WifiDeviceServiceImpl::CheckCanAddDeviceConfig(const bool isCandidate)
669 {
670 int apiVersion = WifiPermissionUtils::GetApiVersion();
671 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
672 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
673 return WIFI_OPT_PERMISSION_DENIED;
674 }
675 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
676 WIFI_LOGE("AddDeviceConfig:VerifySetWifiInfoPermission PERMISSION_DENIED!");
677 return WIFI_OPT_PERMISSION_DENIED;
678 }
679
680 if (!isCandidate) {
681 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
682 WIFI_LOGE("AddDeviceConfig:VerifySetWifiConfigPermission PERMISSION_DENIED!");
683 return WIFI_OPT_PERMISSION_DENIED;
684 }
685 }
686 return WIFI_OPT_SUCCESS;
687 }
688
UpdateDeviceConfig(const WifiDeviceConfig & config,int & result)689 ErrCode WifiDeviceServiceImpl::UpdateDeviceConfig(const WifiDeviceConfig &config, int &result)
690 {
691 if (!WifiAuthCenter::IsSystemAccess()) {
692 WIFI_LOGE("UpdateDeviceConfig: NOT System APP, PERMISSION_DENIED!");
693 return WIFI_OPT_NON_SYSTEMAPP;
694 }
695 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
696 WIFI_LOGE("UpdateDeviceConfig:VerifySetWifiInfoPermission PERMISSION_DENIED!");
697 return WIFI_OPT_PERMISSION_DENIED;
698 }
699
700 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
701 WIFI_LOGE("UpdateDeviceConfig:VerifySetWifiConfigPermission PERMISSION_DENIED!");
702 return WIFI_OPT_PERMISSION_DENIED;
703 }
704
705 if (!IsStaServiceRunning()) {
706 return WIFI_OPT_STA_NOT_OPENED;
707 }
708
709 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
710 if (pService == nullptr) {
711 return WIFI_OPT_STA_NOT_OPENED;
712 }
713
714 int retNetworkId = pService->UpdateDeviceConfig(config);
715 if (retNetworkId <= INVALID_NETWORK_ID) {
716 return WIFI_OPT_FAILED;
717 }
718 result = retNetworkId;
719 return WIFI_OPT_SUCCESS;
720 }
721
RemoveDevice(int networkId)722 ErrCode WifiDeviceServiceImpl::RemoveDevice(int networkId)
723 {
724 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
725 WIFI_LOGE("RemoveDevice:VerifySetWifiInfoPermission PERMISSION_DENIED!");
726 return WIFI_OPT_PERMISSION_DENIED;
727 }
728
729 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED &&
730 WifiPermissionUtils::VerifyEnterpriseWifiConnectionPermission() == PERMISSION_DENIED) {
731 WIFI_LOGE("RemoveDevice:VerifyWifiConnectionPermission PERMISSION_DENIED!");
732 return WIFI_OPT_PERMISSION_DENIED;
733 }
734
735 if (!IsStaServiceRunning()) {
736 return WIFI_OPT_STA_NOT_OPENED;
737 }
738
739 if (networkId < 0) {
740 return WIFI_OPT_INVALID_PARAM;
741 }
742
743 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
744 if (pService == nullptr) {
745 return WIFI_OPT_STA_NOT_OPENED;
746 }
747 return pService->RemoveDevice(networkId);
748 }
749
RemoveAllDevice()750 ErrCode WifiDeviceServiceImpl::RemoveAllDevice()
751 {
752 if (!WifiAuthCenter::IsSystemAccess()) {
753 WIFI_LOGE("RemoveAllDevice:NOT System APP, PERMISSION_DENIED!");
754 return WIFI_OPT_NON_SYSTEMAPP;
755 }
756 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
757 WIFI_LOGE("RemoveAllDevice:VerifySetWifiInfoPermission PERMISSION_DENIED!");
758 return WIFI_OPT_PERMISSION_DENIED;
759 }
760
761 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
762 WIFI_LOGE("RemoveAllDevice:VerifyWifiConnectionPermission PERMISSION_DENIED!");
763 return WIFI_OPT_PERMISSION_DENIED;
764 }
765
766 if (!IsStaServiceRunning()) {
767 return WIFI_OPT_STA_NOT_OPENED;
768 }
769
770 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
771 if (pService == nullptr) {
772 return WIFI_OPT_STA_NOT_OPENED;
773 }
774 return pService->RemoveAllDevice();
775 }
776
SetTxPower(int power)777 ErrCode WifiDeviceServiceImpl::SetTxPower(int power)
778 {
779 if (!WifiAuthCenter::IsSystemAccess()) {
780 WIFI_LOGE("SetTxPower:NOT System APP, PERMISSION_DENIED!");
781 return WIFI_OPT_NON_SYSTEMAPP;
782 }
783 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
784 WIFI_LOGE("setTxPower:VerifySetWifiInfoPermission PERMISSION_DENIED!");
785 return WIFI_OPT_PERMISSION_DENIED;
786 }
787 if (WifiStaHalInterface::GetInstance().SetTxPower(power) != WIFI_HAL_OPT_OK) {
788 WIFI_LOGE("SetTxPower() failed");
789 return WIFI_OPT_FAILED;
790 }
791 return WIFI_OPT_SUCCESS;
792 }
793
SetDpiMarkRule(const std::string & ifaceName,int uid,int protocol,int enable)794 ErrCode WifiDeviceServiceImpl::SetDpiMarkRule(const std::string &ifaceName, int uid, int protocol, int enable)
795 {
796 if (WifiPermissionUtils::VerifySameProcessPermission() == PERMISSION_DENIED) {
797 WIFI_LOGE("SetDpiMarkRule:VerifySameProcessPermission PERMISSION_DENIED!");
798 return WIFI_OPT_PERMISSION_DENIED;
799 }
800
801 if (!IsStaServiceRunning()) {
802 return WIFI_OPT_STA_NOT_OPENED;
803 }
804 if (WifiStaHalInterface::GetInstance().SetDpiMarkRule(ifaceName, uid, protocol, enable) != WIFI_HAL_OPT_OK) {
805 WIFI_LOGE("SetDpiMarkRule failed");
806 return WIFI_OPT_FAILED;
807 }
808 return WIFI_OPT_SUCCESS;
809 }
810
ReplaceConfigWhenCandidateConnected(std::vector<WifiDeviceConfig> & result)811 void WifiDeviceServiceImpl::ReplaceConfigWhenCandidateConnected(std::vector<WifiDeviceConfig> &result)
812 {
813 WifiLinkedInfo linkedInfo;
814 WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo);
815 if (linkedInfo.connState != ConnState::CONNECTED) {
816 return;
817 }
818 WifiDeviceConfig wifiConfig;
819 if (WifiSettings::GetInstance().GetDeviceConfig(linkedInfo.networkId, wifiConfig) != 0) {
820 return;
821 }
822 // -1: Connect by system, use default uid.
823 if (wifiConfig.uid == -1 || wifiConfig.isShared) {
824 return;
825 }
826 for (auto iter = result.begin(); iter != result.end(); iter++) {
827 if (iter->ssid == wifiConfig.ssid && iter->keyMgmt == wifiConfig.keyMgmt) {
828 WIFI_LOGI("ReplaceConfigWhenCandidateConnected networkid: %{public}d!", iter->networkId);
829 result.erase(iter);
830 break;
831 }
832 }
833 result.push_back(wifiConfig);
834 }
835
GetDeviceConfigs(std::vector<WifiDeviceConfig> & result,bool isCandidate)836 ErrCode WifiDeviceServiceImpl::GetDeviceConfigs(std::vector<WifiDeviceConfig> &result, bool isCandidate)
837 {
838 int apiVersion = WifiPermissionUtils::GetApiVersion();
839 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
840 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
841 return WIFI_OPT_PERMISSION_DENIED;
842 } else if (apiVersion == API_VERSION_9) {
843 #ifndef SUPPORT_RANDOM_MAC_ADDR
844 if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
845 WIFI_LOGE("GetDeviceConfigs:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
846 return WIFI_OPT_PERMISSION_DENIED;
847 }
848 #endif
849 }
850 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
851 WIFI_LOGE("GetDeviceConfigs:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
852 return WIFI_OPT_PERMISSION_DENIED;
853 }
854 if (!isCandidate) {
855 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
856 WIFI_LOGE("GetDeviceConfigs:VerifyGetWifiConfigPermission() PERMISSION_DENIED!");
857 return WIFI_OPT_PERMISSION_DENIED;
858 }
859 }
860
861 if (isCandidate) {
862 int uid = 0;
863 if (CheckCallingUid(uid) != WIFI_OPT_SUCCESS) {
864 if (!IsWifiBrokerProcess(uid)) {
865 WIFI_LOGE("IsWifiBrokerProcess failed!");
866 return WIFI_OPT_INVALID_PARAM;
867 }
868 }
869 WifiSettings::GetInstance().GetAllCandidateConfig(uid, result);
870 } else {
871 WifiSettings::GetInstance().GetDeviceConfig(result);
872 ReplaceConfigWhenCandidateConnected(result);
873 }
874 return WIFI_OPT_SUCCESS;
875 }
876
GetDeviceConfig(const int & networkId,WifiDeviceConfig & config)877 ErrCode WifiDeviceServiceImpl::GetDeviceConfig(const int &networkId, WifiDeviceConfig &config)
878 {
879 if (!WifiAuthCenter::IsSystemAccess()) {
880 WIFI_LOGE("GetDeviceConfig:NOT System APP, PERMISSION_DENIED!");
881 return WIFI_OPT_NON_SYSTEMAPP;
882 }
883 if (WifiPermissionUtils::VerifyGetWifiInfoInternalPermission() == PERMISSION_DENIED) {
884 WIFI_LOGE("GetDeviceConfig:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
885
886 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
887 WIFI_LOGE("GetDeviceConfig:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
888 return WIFI_OPT_PERMISSION_DENIED;
889 }
890
891 #ifndef SUPPORT_RANDOM_MAC_ADDR
892 if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
893 WIFI_LOGE("GetDeviceConfig:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
894 return WIFI_OPT_PERMISSION_DENIED;
895 }
896 #endif
897 }
898
899 int ret = WifiSettings::GetInstance().GetDeviceConfig(networkId, config);
900 if (ret != 0) {
901 WIFI_LOGE("GetDeviceConfig: GetDeviceConfig failed! not found networkId = %{public}d", networkId);
902 return WIFI_OPT_INVALID_CONFIG;
903 }
904 return WIFI_OPT_SUCCESS;
905 }
906
EnableDeviceConfig(int networkId,bool attemptEnable)907 ErrCode WifiDeviceServiceImpl::EnableDeviceConfig(int networkId, bool attemptEnable)
908 {
909 if (!WifiAuthCenter::IsSystemAccess()) {
910 WIFI_LOGE("EnableDeviceConfig:NOT System APP, PERMISSION_DENIED!");
911 return WIFI_OPT_NON_SYSTEMAPP;
912 }
913 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
914 WIFI_LOGE("EnableDeviceConfig:VerifySetWifiInfoPermission PERMISSION_DENIED!");
915 return WIFI_OPT_PERMISSION_DENIED;
916 }
917
918 if (!IsStaServiceRunning()) {
919 return WIFI_OPT_STA_NOT_OPENED;
920 }
921
922 if (networkId < 0) {
923 return WIFI_OPT_INVALID_PARAM;
924 }
925
926 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
927 if (pService == nullptr) {
928 return WIFI_OPT_STA_NOT_OPENED;
929 }
930 return pService->EnableDeviceConfig(networkId, attemptEnable);
931 }
932
DisableDeviceConfig(int networkId)933 ErrCode WifiDeviceServiceImpl::DisableDeviceConfig(int networkId)
934 {
935 if (!WifiAuthCenter::IsSystemAccess()) {
936 WIFI_LOGE("DisableDeviceConfig:NOT System APP, PERMISSION_DENIED!");
937 return WIFI_OPT_NON_SYSTEMAPP;
938 }
939 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
940 WIFI_LOGE("DisableDeviceConfig:VerifySetWifiInfoPermission PERMISSION_DENIED!");
941 return WIFI_OPT_PERMISSION_DENIED;
942 }
943
944 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
945 WIFI_LOGE("DisableDeviceConfig:VerifySetWifiInfoPermission PERMISSION_DENIED!");
946 return WIFI_OPT_PERMISSION_DENIED;
947 }
948
949 if (!IsStaServiceRunning()) {
950 return WIFI_OPT_STA_NOT_OPENED;
951 }
952
953 if (networkId < 0) {
954 return WIFI_OPT_INVALID_PARAM;
955 }
956
957 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
958 if (pService == nullptr) {
959 return WIFI_OPT_STA_NOT_OPENED;
960 }
961 return pService->DisableDeviceConfig(networkId);
962 }
963
AllowAutoConnect(int32_t networkId,bool isAllowed)964 ErrCode WifiDeviceServiceImpl::AllowAutoConnect(int32_t networkId, bool isAllowed)
965 {
966 if (!WifiAuthCenter::IsSystemAccess()) {
967 WIFI_LOGE("AllowAutoConnect:NOT System APP, PERMISSION_DENIED!");
968 return WIFI_OPT_NON_SYSTEMAPP;
969 }
970 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
971 WIFI_LOGE("AllowAutoConnect:VerifySetWifiInfoPermission PERMISSION_DENIED!");
972 return WIFI_OPT_PERMISSION_DENIED;
973 }
974
975 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
976 WIFI_LOGE("AllowAutoConnect:VerifySetWifiInfoPermission PERMISSION_DENIED!");
977 return WIFI_OPT_PERMISSION_DENIED;
978 }
979
980 if (!IsStaServiceRunning()) {
981 return WIFI_OPT_STA_NOT_OPENED;
982 }
983
984 if (networkId < 0) {
985 return WIFI_OPT_INVALID_PARAM;
986 }
987
988 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
989 if (pService == nullptr) {
990 return WIFI_OPT_STA_NOT_OPENED;
991 }
992 return pService->AllowAutoConnect(networkId, isAllowed);
993 }
994
ConnectToNetwork(int networkId,bool isCandidate)995 ErrCode WifiDeviceServiceImpl::ConnectToNetwork(int networkId, bool isCandidate)
996 {
997 if (IsOtherVapConnect()) {
998 LOGI("ConnectToNetwork: p2p or hml connected, and hotspot is enable");
999 #ifndef OHOS_ARCH_LITE
1000 WifiManager::GetInstance().GetWifiMultiVapManager()->VapConflictReport();
1001 #endif
1002 WifiManager::GetInstance().GetWifiTogglerManager()->SoftapToggled(0, 0);
1003 }
1004 #ifndef OHOS_ARCH_LITE
1005 if (WifiManager::GetInstance().GetWifiMultiVapManager()->CheckEnhanceWifiConnected() &&
1006 WifiManager::GetInstance().GetWifiMultiVapManager()->CheckP2pConnected()) {
1007 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1008 if (pService == nullptr) {
1009 WIFI_LOGE("Get P2P service failed");
1010 } else {
1011 ErrCode ret = pService->RemoveGroup();
1012 WIFI_LOGI("P2P RemoveGroup ret is %{public}d", ret);
1013 }
1014 }
1015 #endif
1016 int apiVersion = WifiPermissionUtils::GetApiVersion();
1017 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
1018 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
1019 return WIFI_OPT_PERMISSION_DENIED;
1020 }
1021 if (isCandidate) {
1022 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1023 WIFI_LOGE("ConnectToCandidateConfig:VerifySetWifiInfoPermission PERMISSION_DENIED!");
1024 return WIFI_OPT_PERMISSION_DENIED;
1025 }
1026 } else {
1027 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED &&
1028 WifiPermissionUtils::VerifyEnterpriseWifiConnectionPermission() == PERMISSION_DENIED) {
1029 WIFI_LOGE("ConnectToNetwork:VerifyWifiConnectionPermission PERMISSION_DENIED!");
1030 return WIFI_OPT_PERMISSION_DENIED;
1031 }
1032 }
1033 WifiManager::GetInstance().StopGetCacResultAndLocalCac(CAC_STOP_BY_STA_REQUEST);
1034
1035 if (!IsStaServiceRunning()) {
1036 WIFI_LOGE("ConnectToNetwork: sta service is not running!");
1037 return WIFI_OPT_STA_NOT_OPENED;
1038 }
1039
1040 if (networkId < 0) {
1041 WIFI_LOGE("ConnectToNetwork: invalid networkId = %{public}d!", networkId);
1042 return WIFI_OPT_INVALID_PARAM;
1043 }
1044
1045 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1046 if (pService == nullptr) {
1047 WIFI_LOGE("ConnectToNetwork: pService is nullptr!");
1048 return WIFI_OPT_STA_NOT_OPENED;
1049 }
1050 SetWifiConnectedMode();
1051 if (isCandidate) {
1052 int uid = 0;
1053 if (CheckCallingUid(uid) != WIFI_OPT_SUCCESS) {
1054 if (!IsWifiBrokerProcess(uid)) {
1055 WIFI_LOGE("ConnectToNetwork IsWifiBrokerProcess failed!");
1056 return WIFI_OPT_INVALID_PARAM;
1057 }
1058 }
1059 BlockConnectService::GetInstance().EnableNetworkSelectStatus(networkId);
1060 return pService->ConnectToCandidateConfig(uid, networkId);
1061 }
1062 return pService->ConnectToNetwork(networkId);
1063 }
1064
ConnectToDevice(const WifiDeviceConfig & config)1065 ErrCode WifiDeviceServiceImpl::ConnectToDevice(const WifiDeviceConfig &config)
1066 {
1067 WIFI_LOGI("%{public}s: device address %{private}s, addressType:%{public}d",
1068 __func__, config.bssid.c_str(), config.bssidType);
1069 if (!WifiAuthCenter::IsSystemAccess()) {
1070 WIFI_LOGE("ConnectToDevice:NOT System APP, PERMISSION_DENIED!");
1071 return WIFI_OPT_NON_SYSTEMAPP;
1072 }
1073 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1074 WIFI_LOGE("ConnectToDevice:VerifySetWifiInfoPermission PERMISSION_DENIED!");
1075 return WIFI_OPT_PERMISSION_DENIED;
1076 }
1077
1078 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1079 WIFI_LOGE("ConnectToDevice:VerifyWifiConnectionPermission PERMISSION_DENIED!");
1080 return WIFI_OPT_PERMISSION_DENIED;
1081 }
1082
1083 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
1084 WIFI_LOGE("ConnectToDevice:VerifySetWifiConfigPermission PERMISSION_DENIED!");
1085 return WIFI_OPT_PERMISSION_DENIED;
1086 }
1087 WifiManager::GetInstance().StopGetCacResultAndLocalCac(CAC_STOP_BY_STA_REQUEST);
1088
1089 if (!CheckConfigPwd(config)) {
1090 WIFI_LOGE("CheckConfigPwd failed!");
1091 return WIFI_OPT_INVALID_PARAM;
1092 }
1093 if (!IsStaServiceRunning()) {
1094 WIFI_LOGE("ConnectToDevice: sta service is not running!");
1095 return WIFI_OPT_STA_NOT_OPENED;
1096 }
1097 WifiDeviceConfig updateConfig = config;
1098 #ifdef SUPPORT_RANDOM_MAC_ADDR
1099 if (MacAddress::IsValidMac(config.bssid)) {
1100 if (config.bssidType > REAL_DEVICE_ADDRESS) {
1101 WIFI_LOGE("%{public}s: invalid bssidType:%{public}d", __func__, config.bssidType);
1102 return WIFI_OPT_INVALID_PARAM;
1103 }
1104 WifiMacAddrInfo macAddrInfo;
1105 macAddrInfo.bssid = config.bssid;
1106 macAddrInfo.bssidType = config.bssidType;
1107 std::string randomMacAddr =
1108 WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO,
1109 macAddrInfo);
1110 if (randomMacAddr.empty()) {
1111 WIFI_LOGW("%{public}s: record not found, bssid:%{private}s, bssidType:%{public}d",
1112 __func__, macAddrInfo.bssid.c_str(), macAddrInfo.bssidType);
1113 } else {
1114 WIFI_LOGI("%{public}s: find the record, bssid:%{private}s, bssidType:%{public}d, randomMac:%{private}s",
1115 __func__, config.bssid.c_str(), config.bssidType, randomMacAddr.c_str());
1116 /* random MAC address are translated into real MAC address */
1117 if (config.bssidType == RANDOM_DEVICE_ADDRESS) {
1118 updateConfig.bssid = randomMacAddr;
1119 updateConfig.bssidType = REAL_DEVICE_ADDRESS;
1120 WIFI_LOGI("%{public}s: the record is updated, bssid:%{private}s, bssidType:%{public}d, randomMac:%{private}s",
1121 __func__, updateConfig.bssid.c_str(), updateConfig.bssidType, randomMacAddr.c_str());
1122 }
1123 }
1124 }
1125 #endif
1126
1127 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1128 if (pService == nullptr) {
1129 WIFI_LOGE("ConnectToNetwork: pService is nullptr!");
1130 return WIFI_OPT_STA_NOT_OPENED;
1131 }
1132 SetWifiConnectedMode();
1133 return pService->ConnectToDevice(updateConfig);
1134 }
1135
StartRoamToNetwork(const int networkId,const std::string bssid,const bool isCandidate)1136 ErrCode WifiDeviceServiceImpl::StartRoamToNetwork(const int networkId, const std::string bssid, const bool isCandidate)
1137 {
1138 #ifndef OHOS_ARCH_LITE
1139 WIFI_LOGI("%{public}s enter, pid:%{public}d, uid:%{public}d, BundleName:%{public}s.",
1140 __FUNCTION__, GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
1141 #endif
1142 if (isCandidate) {
1143 WIFI_LOGE("%{public}s: don't support roam to candidate network", __FUNCTION__);
1144 return WIFI_OPT_NOT_SUPPORTED;
1145 }
1146 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1147 WIFI_LOGE("%{public}s:VerifyWifiConnectionPermission PERMISSION_DENIED!", __FUNCTION__);
1148 return WIFI_OPT_PERMISSION_DENIED;
1149 }
1150 if (!IsStaServiceRunning()) {
1151 WIFI_LOGE("%{public}s: sta service is not running!", __FUNCTION__);
1152 return WIFI_OPT_STA_NOT_OPENED;
1153 }
1154 if (networkId < 0 || (!bssid.empty() && CheckMacIsValid(bssid) != 0)) {
1155 WIFI_LOGE("%{public}s: invalid param, networkId: %{public}d, bssid:%{public}s",
1156 __FUNCTION__, networkId, MacAnonymize(bssid).c_str());
1157 return WIFI_OPT_INVALID_PARAM;
1158 }
1159 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1160 if (pService == nullptr) {
1161 WIFI_LOGE("%{public}s: pService is nullptr!", __FUNCTION__);
1162 return WIFI_OPT_STA_NOT_OPENED;
1163 }
1164 return pService->StartConnectToBssid(networkId, bssid);
1165 }
1166
StartConnectToUserSelectNetwork(int networkId,std::string bssid,bool isCandidate)1167 ErrCode WifiDeviceServiceImpl::StartConnectToUserSelectNetwork(int networkId, std::string bssid, bool isCandidate)
1168 {
1169 #ifndef OHOS_ARCH_LITE
1170 WIFI_LOGI("%{public}s enter, pid:%{public}d, uid:%{public}d, BundleName:%{public}s.",
1171 __FUNCTION__, GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
1172 #endif
1173 if (isCandidate) {
1174 WIFI_LOGE("%{public}s: do not support connect to user select candidate network", __FUNCTION__);
1175 return WIFI_OPT_NOT_SUPPORTED;
1176 }
1177 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1178 WIFI_LOGE("%{public}s:VerifyWifiConnectionPermission PERMISSION_DENIED!", __FUNCTION__);
1179 return WIFI_OPT_PERMISSION_DENIED;
1180 }
1181 if (!IsStaServiceRunning()) {
1182 WIFI_LOGE("%{public}s: sta service is not running", __FUNCTION__);
1183 return WIFI_OPT_STA_NOT_OPENED;
1184 }
1185 if (networkId < 0 || (!bssid.empty() && CheckMacIsValid(bssid) != 0)) {
1186 WIFI_LOGE("%{public}s: invalid param, networkId: %{public}d, bssid:%{public}s",
1187 __FUNCTION__, networkId, MacAnonymize(bssid).c_str());
1188 return WIFI_OPT_INVALID_PARAM;
1189 }
1190 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1191 if (pService == nullptr) {
1192 WIFI_LOGE("%{public}s: pService is nullptr", __FUNCTION__);
1193 return WIFI_OPT_STA_NOT_OPENED;
1194 }
1195 return pService->StartConnectToUserSelectNetwork(networkId, bssid);
1196 }
1197
IsConnected(bool & isConnected)1198 ErrCode WifiDeviceServiceImpl::IsConnected(bool &isConnected)
1199 {
1200 WifiLinkedInfo linkedInfo;
1201
1202 int apiVersion = WifiPermissionUtils::GetApiVersion();
1203 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
1204 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
1205 return WIFI_OPT_PERMISSION_DENIED;
1206 }
1207 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1208 WIFI_LOGE("IsConnected:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1209 return WIFI_OPT_PERMISSION_DENIED;
1210 }
1211
1212 WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo, m_instId);
1213 isConnected = (linkedInfo.connState == ConnState::CONNECTED);
1214 return WIFI_OPT_SUCCESS;
1215 }
1216
ReConnect()1217 ErrCode WifiDeviceServiceImpl::ReConnect()
1218 {
1219 if (!WifiAuthCenter::IsSystemAccess()) {
1220 WIFI_LOGE("ReConnect:NOT System APP, PERMISSION_DENIED!");
1221 return WIFI_OPT_NON_SYSTEMAPP;
1222 }
1223 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1224 WIFI_LOGE("ReConnect:VerifySetWifiInfoPermission() PERMISSION_DENIED!");
1225 return WIFI_OPT_PERMISSION_DENIED;
1226 }
1227
1228 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1229 WIFI_LOGE("ReConnect:VerifyWifiConnectionPermission() PERMISSION_DENIED!");
1230 return WIFI_OPT_PERMISSION_DENIED;
1231 }
1232
1233 if (!IsStaServiceRunning()) {
1234 return WIFI_OPT_STA_NOT_OPENED;
1235 }
1236
1237 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1238 if (pService == nullptr) {
1239 return WIFI_OPT_STA_NOT_OPENED;
1240 }
1241 SetWifiConnectedMode();
1242 return pService->ReConnect();
1243 }
1244
ReAssociate(void)1245 ErrCode WifiDeviceServiceImpl::ReAssociate(void)
1246 {
1247 if (!WifiAuthCenter::IsSystemAccess()) {
1248 WIFI_LOGE("ReAssociate:NOT System APP, PERMISSION_DENIED!");
1249 return WIFI_OPT_NON_SYSTEMAPP;
1250 }
1251
1252 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1253 WIFI_LOGE("ReAssociate:VerifySetWifiInfoPermission PERMISSION_DENIED!");
1254 return WIFI_OPT_PERMISSION_DENIED;
1255 }
1256
1257 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1258 WIFI_LOGE("ReAssociate:VerifyWifiConnectionPermission() PERMISSION_DENIED!");
1259 return WIFI_OPT_PERMISSION_DENIED;
1260 }
1261
1262 if (!IsStaServiceRunning()) {
1263 return WIFI_OPT_STA_NOT_OPENED;
1264 }
1265
1266 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1267 if (pService == nullptr) {
1268 return WIFI_OPT_STA_NOT_OPENED;
1269 }
1270 return pService->ReAssociate();
1271 }
1272
Disconnect(void)1273 ErrCode WifiDeviceServiceImpl::Disconnect(void)
1274 {
1275 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1276 WIFI_LOGE("Disconnect:VerifySetWifiInfoPermission() PERMISSION_DENIED!");
1277 return WIFI_OPT_PERMISSION_DENIED;
1278 }
1279
1280 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED &&
1281 WifiPermissionUtils::VerifyEnterpriseWifiConnectionPermission() == PERMISSION_DENIED) {
1282 WIFI_LOGE("Disconnect:VerifyWifiConnectionPermission() PERMISSION_DENIED!");
1283 return WIFI_OPT_PERMISSION_DENIED;
1284 }
1285
1286 if (!IsStaServiceRunning()) {
1287 return WIFI_OPT_STA_NOT_OPENED;
1288 }
1289
1290 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1291 if (pService == nullptr) {
1292 return WIFI_OPT_STA_NOT_OPENED;
1293 }
1294 return pService->Disconnect();
1295 }
1296
StartWps(const WpsConfig & config)1297 ErrCode WifiDeviceServiceImpl::StartWps(const WpsConfig &config)
1298 {
1299 if (!WifiAuthCenter::IsSystemAccess()) {
1300 WIFI_LOGE("GetScanOnlyAvailable: NOT System APP, PERMISSION_DENIED!");
1301 return WIFI_OPT_NON_SYSTEMAPP;
1302 }
1303
1304 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
1305 WIFI_LOGE("StartWps:VerifyGetWifiConfigPermission() PERMISSION_DENIED!");
1306 return WIFI_OPT_PERMISSION_DENIED;
1307 }
1308
1309 if (!IsStaServiceRunning()) {
1310 return WIFI_OPT_STA_NOT_OPENED;
1311 }
1312
1313 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1314 if (pService == nullptr) {
1315 return WIFI_OPT_STA_NOT_OPENED;
1316 }
1317 return pService->StartWps(config);
1318 }
1319
CancelWps(void)1320 ErrCode WifiDeviceServiceImpl::CancelWps(void)
1321 {
1322 if (!WifiAuthCenter::IsSystemAccess()) {
1323 WIFI_LOGE("GetScanOnlyAvailable: NOT System APP, PERMISSION_DENIED!");
1324 return WIFI_OPT_NON_SYSTEMAPP;
1325 }
1326
1327 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
1328 WIFI_LOGE("CancelWps:VerifyGetWifiConfigPermission() PERMISSION_DENIED!");
1329 return WIFI_OPT_PERMISSION_DENIED;
1330 }
1331
1332 if (!IsStaServiceRunning()) {
1333 return WIFI_OPT_STA_NOT_OPENED;
1334 }
1335
1336 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1337 if (pService == nullptr) {
1338 return WIFI_OPT_STA_NOT_OPENED;
1339 }
1340 return pService->CancelWps();
1341 }
1342
IsWifiActive(bool & bActive)1343 ErrCode WifiDeviceServiceImpl::IsWifiActive(bool &bActive)
1344 {
1345 int apiVersion = WifiPermissionUtils::GetApiVersion();
1346 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
1347 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
1348 return WIFI_OPT_PERMISSION_DENIED;
1349 }
1350
1351 bActive = IsStaServiceRunning();
1352 return WIFI_OPT_SUCCESS;
1353 }
1354
GetWifiState(int & state)1355 ErrCode WifiDeviceServiceImpl::GetWifiState(int &state)
1356 {
1357 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1358 WIFI_LOGE("GetWifiState:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1359 return WIFI_OPT_PERMISSION_DENIED;
1360 }
1361
1362 state = WifiConfigCenter::GetInstance().GetWifiState(m_instId);
1363 return WIFI_OPT_SUCCESS;
1364 }
1365
IsMeteredHotspot(bool & bMeteredHotspot)1366 ErrCode WifiDeviceServiceImpl::IsMeteredHotspot(bool &bMeteredHotspot)
1367 {
1368 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1369 WIFI_LOGE("IsMeteredHotspot:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1370 return WIFI_OPT_PERMISSION_DENIED;
1371 }
1372
1373 if (!IsStaServiceRunning()) {
1374 return WIFI_OPT_STA_NOT_OPENED;
1375 }
1376
1377 WifiLinkedInfo info;
1378 WifiConfigCenter::GetInstance().GetLinkedInfo(info, m_instId);
1379 WIFI_LOGD("%{public}s, connState=%{public}d, detailedState=%{public}d",
1380 __func__, info.connState, info.detailedState);
1381 if (info.connState != ConnState::CONNECTED) {
1382 return WIFI_OPT_FAILED;
1383 }
1384 bMeteredHotspot = info.isDataRestricted;
1385 return WIFI_OPT_SUCCESS;
1386 }
1387
VerifyGetLinkedInfofoPermission()1388 static ErrCode VerifyGetLinkedInfofoPermission()
1389 {
1390 int apiVersion = WifiPermissionUtils::GetApiVersion();
1391 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
1392 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
1393 return WIFI_OPT_PERMISSION_DENIED;
1394 }
1395 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1396 WIFI_LOGE("GetLinkedInfo:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1397 return WIFI_OPT_PERMISSION_DENIED;
1398 }
1399
1400 return WIFI_OPT_SUCCESS;
1401 }
1402
GetLinkedInfo(WifiLinkedInfo & info)1403 ErrCode WifiDeviceServiceImpl::GetLinkedInfo(WifiLinkedInfo &info)
1404 {
1405 if (VerifyGetLinkedInfofoPermission() != WIFI_OPT_SUCCESS) {
1406 return WIFI_OPT_PERMISSION_DENIED;
1407 }
1408 if (!IsStaServiceRunning()) {
1409 return WIFI_OPT_STA_NOT_OPENED;
1410 }
1411 WifiConfigCenter::GetInstance().GetLinkedInfo(info, m_instId);
1412 UpdateWifiLinkInfo(info);
1413 return WIFI_OPT_SUCCESS;
1414 }
1415
GetMultiLinkedInfo(std::vector<WifiLinkedInfo> & mloLinkInfo)1416 ErrCode WifiDeviceServiceImpl::GetMultiLinkedInfo(std::vector<WifiLinkedInfo> &mloLinkInfo)
1417 {
1418 #ifndef OHOS_ARCH_LITE
1419 WIFI_LOGI("GetMultiLinkedInfo, pid:%{public}d, uid:%{public}d, BundleName:%{public}s.",
1420 GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
1421 #endif
1422 if (VerifyGetLinkedInfofoPermission() != WIFI_OPT_SUCCESS) {
1423 return WIFI_OPT_PERMISSION_DENIED;
1424 }
1425 if (!IsStaServiceRunning()) {
1426 return WIFI_OPT_STA_NOT_OPENED;
1427 }
1428 if (WifiConfigCenter::GetInstance().GetMloLinkedInfo(mloLinkInfo, m_instId) < 0) {
1429 WIFI_LOGE("GetMultiLinkedInfo failed, not find valid mloLinkInfo");
1430 return WIFI_OPT_FAILED;
1431 }
1432 for (auto &info : mloLinkInfo) {
1433 UpdateWifiLinkInfo(info);
1434 }
1435 return WIFI_OPT_SUCCESS;
1436 }
1437
UpdateWifiLinkInfo(WifiLinkedInfo & info)1438 void WifiDeviceServiceImpl::UpdateWifiLinkInfo(WifiLinkedInfo &info)
1439 {
1440 if (info.macType == static_cast<int>(WifiPrivacyConfig::DEVICEMAC)) {
1441 if (WifiPermissionUtils::VerifyGetWifiLocalMacPermission() == PERMISSION_DENIED) {
1442 WIFI_LOGD("GetLinkedInfo:VerifyGetWifiLocalMacPermission() PERMISSION_DENIED!");
1443 /* Clear mac addr */
1444 info.macAddress = "";
1445 }
1446 }
1447
1448 std::string appId = "";
1449 std::string packageName = "";
1450 #ifndef OHOS_ARCH_LITE
1451 GetBundleNameByUid(GetCallingUid(), packageName);
1452 appId = GetBundleAppIdByBundleName(GetCallingUid(), packageName);
1453 #endif
1454 if (ProcessPermissionVerify(appId, packageName) == PERMISSION_DENIED) {
1455 if (WifiPermissionUtils::VerifyGetWifiPeersMacPermission() == PERMISSION_DENIED) {
1456 WIFI_LOGD("GetLinkedInfo:VerifyGetWifiPeersMacPermission() PERMISSION_DENIED!");
1457 #ifdef SUPPORT_RANDOM_MAC_ADDR
1458 info.bssid = WifiConfigCenter::GetInstance().GetRandomMacAddr(WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO,
1459 info.bssid);
1460 #else
1461 /* Clear mac addr */
1462 info.bssid = "";
1463 #endif
1464 }
1465 }
1466 #ifndef OHOS_ARCH_LITE
1467 ISelfCureService *pSelfCureService = WifiServiceManager::GetInstance().GetSelfCureServiceInst();
1468 if ((pSelfCureService != nullptr) && (pSelfCureService->IsSelfCureL2Connecting())) {
1469 info.connState = ConnState::CONNECTED;
1470 }
1471 #endif // FEATURE_SELF_CURE_SUPPORT
1472 WIFI_LOGD("GetLinkedInfo, networkId=%{public}d, ssid=%{public}s, rssi=%{public}d, frequency=%{public}d",
1473 info.networkId, SsidAnonymize(info.ssid).c_str(), info.rssi, info.frequency);
1474 WIFI_LOGD("GetLinkedInfo, connState=%{public}d, supplicantState=%{public}d, detailedState=%{public}d,\
1475 wifiStandard=%{public}d RxMaxSpeed=%{public}d TxmaxSpeed=%{public}d rxSpeed=%{public}d txSpeed=%{public}d",
1476 info.connState, info.supplicantState, info.detailedState, info.wifiStandard,
1477 info.maxSupportedRxLinkSpeed, info.maxSupportedTxLinkSpeed, info.rxLinkSpeed, info.txLinkSpeed);
1478 info.isAncoConnected = WifiConfigCenter::GetInstance().GetWifiConnectedMode(m_instId);
1479 }
1480
GetSignalPollInfoArray(std::vector<WifiSignalPollInfo> & wifiSignalPollInfos,int length)1481 ErrCode WifiDeviceServiceImpl::GetSignalPollInfoArray(std::vector<WifiSignalPollInfo> &wifiSignalPollInfos, int length)
1482 {
1483 if (!WifiAuthCenter::IsNativeProcess()) {
1484 WIFI_LOGE("%{public}s NOT NATIVE PROCESS, PERMISSION_DENIED!", __FUNCTION__);
1485 return WIFI_OPT_NON_SYSTEMAPP;
1486 }
1487 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1488 WIFI_LOGE("GetSignalPollInfoArray:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1489 return WIFI_OPT_PERMISSION_DENIED;
1490 }
1491 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
1492 if (pService == nullptr) {
1493 return WIFI_OPT_STA_NOT_OPENED;
1494 }
1495 return pService->GetSignalPollInfoArray(wifiSignalPollInfos, length);
1496 }
1497
GetDisconnectedReason(DisconnectedReason & reason)1498 ErrCode WifiDeviceServiceImpl::GetDisconnectedReason(DisconnectedReason &reason)
1499 {
1500 if (!WifiAuthCenter::IsSystemAccess()) {
1501 WIFI_LOGE("GetDisconnectedReason:NOT System APP, PERMISSION_DENIED!");
1502 return WIFI_OPT_NON_SYSTEMAPP;
1503 }
1504 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1505 WIFI_LOGE("GetDisconnectedReason:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1506 return WIFI_OPT_PERMISSION_DENIED;
1507 }
1508 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
1509 WIFI_LOGE("GetDisconnectedReason:VerifyGetWifiConfigPermission() PERMISSION_DENIED!");
1510 return WIFI_OPT_PERMISSION_DENIED;
1511 }
1512
1513 if (!IsStaServiceRunning()) {
1514 return WIFI_OPT_STA_NOT_OPENED;
1515 }
1516 WifiLinkedInfo info;
1517 WifiConfigCenter::GetInstance().GetLinkedInfo(info, m_instId);
1518 WIFI_LOGI("%{public}s, connState=%{public}d, detailedState=%{public}d",
1519 __func__, info.connState, info.detailedState);
1520 if (info.connState == ConnState::CONNECTING || info.connState == ConnState::CONNECTED) {
1521 return WIFI_OPT_FAILED;
1522 }
1523 WifiConfigCenter::GetInstance().GetDisconnectedReason(reason, m_instId);
1524 return WIFI_OPT_SUCCESS;
1525 }
1526
GetIpInfo(IpInfo & info)1527 ErrCode WifiDeviceServiceImpl::GetIpInfo(IpInfo &info)
1528 {
1529 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1530 WIFI_LOGE("GetIpInfo:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1531 return WIFI_OPT_PERMISSION_DENIED;
1532 }
1533
1534 WifiConfigCenter::GetInstance().GetIpInfo(info, m_instId);
1535 return WIFI_OPT_SUCCESS;
1536 }
1537
GetIpv6Info(IpV6Info & info)1538 ErrCode WifiDeviceServiceImpl::GetIpv6Info(IpV6Info &info)
1539 {
1540 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1541 WIFI_LOGE("GetIpv6Info:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1542 return WIFI_OPT_PERMISSION_DENIED;
1543 }
1544
1545 WifiConfigCenter::GetInstance().GetIpv6Info(info, m_instId);
1546 return WIFI_OPT_SUCCESS;
1547 }
1548
SetCountryCode(const std::string & countryCode)1549 ErrCode WifiDeviceServiceImpl::SetCountryCode(const std::string &countryCode)
1550 {
1551 if (countryCode.length() != WIFI_COUNTRY_CODE_LEN) {
1552 return WIFI_OPT_INVALID_PARAM;
1553 }
1554 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1555 WIFI_LOGE("SetCountryCode:VerifyWifiConnectionPermission() PERMISSION_DENIED!");
1556 return WIFI_OPT_PERMISSION_DENIED;
1557 }
1558
1559 if (!IsStaServiceRunning()) {
1560 return WIFI_OPT_STA_NOT_OPENED;
1561 }
1562 #ifndef OHOS_ARCH_LITE
1563 WIFI_LOGI("set country code from external");
1564 return WifiCountryCodeManager::GetInstance().SetWifiCountryCodeFromExternal(countryCode);
1565 #else
1566 return WIFI_OPT_SUCCESS;
1567 #endif
1568 }
1569
GetCountryCode(std::string & countryCode)1570 ErrCode WifiDeviceServiceImpl::GetCountryCode(std::string &countryCode)
1571 {
1572 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1573 WIFI_LOGE("GetCountryCode:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1574 return WIFI_OPT_PERMISSION_DENIED;
1575 }
1576 #ifndef OHOS_ARCH_LITE
1577 WifiCountryCodeManager::GetInstance().GetWifiCountryCode(countryCode);
1578 WIFI_LOGD("GetCountryCode: country code is %{public}s", countryCode.c_str());
1579 #endif
1580 return WIFI_OPT_SUCCESS;
1581 }
1582
GetWifiDetailState(WifiDetailState & state)1583 ErrCode WifiDeviceServiceImpl::GetWifiDetailState(WifiDetailState &state)
1584 {
1585 if (!WifiAuthCenter::IsSystemAccess()) {
1586 WIFI_LOGE("GetWifiDetailState: NOT System APP, PERMISSION_DENIED!");
1587 return WIFI_OPT_NON_SYSTEMAPP;
1588 }
1589 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1590 WIFI_LOGE("GetWifiDetailState:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1591 return WIFI_OPT_PERMISSION_DENIED;
1592 }
1593 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1594 WIFI_LOGE("GetWifiDetailState:VerifyWifiConnectionPermission PERMISSION_DENIED!");
1595 return WIFI_OPT_PERMISSION_DENIED;
1596 }
1597 state = WifiConfigCenter::GetInstance().GetWifiDetailState(m_instId);
1598 WIFI_LOGI("GetWifiDetailState: state is %{public}d", static_cast<int>(state));
1599 return WIFI_OPT_SUCCESS;
1600 }
1601
1602 #ifdef OHOS_ARCH_LITE
RegisterCallBack(const std::shared_ptr<IWifiDeviceCallBack> & callback,const std::vector<std::string> & event)1603 ErrCode WifiDeviceServiceImpl::RegisterCallBack(const std::shared_ptr<IWifiDeviceCallBack> &callback,
1604 const std::vector<std::string> &event)
1605 #else
1606 ErrCode WifiDeviceServiceImpl::RegisterCallBack(const sptr<IWifiDeviceCallBack> &callback,
1607 const std::vector<std::string> &event)
1608 #endif
1609 {
1610 WIFI_LOGI("RegisterCallBack");
1611 if (callback == nullptr) {
1612 WIFI_LOGE("Get call back client failed!");
1613 return WIFI_OPT_FAILED;
1614 }
1615
1616 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1617 WIFI_LOGE("RegisterCallBackClient:VerifyWifiConnectionPermission() PERMISSION_DENIED!");
1618 return WIFI_OPT_PERMISSION_DENIED;
1619 }
1620
1621 for (const auto &eventName : event) {
1622 WifiInternalEventDispatcher::GetInstance().SetSingleStaCallback(callback, eventName, m_instId);
1623 }
1624 return WIFI_OPT_SUCCESS;
1625 }
1626
GetSignalLevel(const int & rssi,const int & band,int & level)1627 ErrCode WifiDeviceServiceImpl::GetSignalLevel(const int &rssi, const int &band, int &level)
1628 {
1629 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1630 WIFI_LOGE("GetSignalLevel:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1631 return WIFI_OPT_PERMISSION_DENIED;
1632 }
1633
1634 level = WifiSettings::GetInstance().GetSignalLevel(rssi, band, m_instId);
1635 return WIFI_OPT_SUCCESS;
1636 }
1637
GetSupportedFeatures(long & features)1638 ErrCode WifiDeviceServiceImpl::GetSupportedFeatures(long &features)
1639 {
1640 if (!WifiAuthCenter::IsSystemAccess()) {
1641 WIFI_LOGE("GetSupportedFeatures:NOT System APP, PERMISSION_DENIED!");
1642 return WIFI_OPT_NON_SYSTEMAPP;
1643 }
1644 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1645 WIFI_LOGE("GetSupportedFeatures:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1646 return WIFI_OPT_PERMISSION_DENIED;
1647 }
1648 int ret = WifiManager::GetInstance().GetSupportedFeatures(features);
1649 if (ret < 0) {
1650 WIFI_LOGE("Failed to get supported features!");
1651 return WIFI_OPT_FAILED;
1652 }
1653 return WIFI_OPT_SUCCESS;
1654 }
1655
IsFeatureSupported(long feature,bool & isSupported)1656 ErrCode WifiDeviceServiceImpl::IsFeatureSupported(long feature, bool &isSupported)
1657 {
1658 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1659 WIFI_LOGE("GetSupportedFeatures:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1660 return WIFI_OPT_PERMISSION_DENIED;
1661 }
1662 long tmpFeatures = 0;
1663 int ret = WifiManager::GetInstance().GetSupportedFeatures(tmpFeatures);
1664 if (ret < 0) {
1665 WIFI_LOGE("Failed to get supported features!");
1666 return WIFI_OPT_FAILED;
1667 }
1668 isSupported = ((static_cast<unsigned long>(tmpFeatures) & static_cast<unsigned long>(feature)) ==
1669 static_cast<unsigned long>(feature));
1670 return WIFI_OPT_SUCCESS;
1671 }
1672
GetDeviceMacAddress(std::string & result)1673 ErrCode WifiDeviceServiceImpl::GetDeviceMacAddress(std::string &result)
1674 {
1675 WIFI_LOGI("GetDeviceMacAddress");
1676 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1677 WIFI_LOGE("GetDeviceMacAddress:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1678 return WIFI_OPT_PERMISSION_DENIED;
1679 }
1680
1681 if (WifiPermissionUtils::VerifyGetWifiLocalMacPermission() == PERMISSION_DENIED) {
1682 WIFI_LOGE("GetDeviceMacAddress:VerifyGetWifiLocalMacPermission PERMISSION_DENIED!");
1683 return WIFI_OPT_PERMISSION_DENIED;
1684 }
1685
1686 /* mac will be got from hal when wifi is enabled. if wifi is disabled, we don't return mac. */
1687 if (!IsStaServiceRunning()) {
1688 return WIFI_OPT_STA_NOT_OPENED;
1689 }
1690
1691 WifiSettings::GetInstance().GetRealMacAddress(result);
1692 return WIFI_OPT_SUCCESS;
1693 }
1694
SetLowLatencyMode(bool enabled)1695 bool WifiDeviceServiceImpl::SetLowLatencyMode(bool enabled)
1696 {
1697 WIFI_LOGI("SetLowLatencyMode");
1698 /* refer to WifiProtectManager::GetInstance().SetLowLatencyMode, DO NOT support now! */
1699 return true;
1700 }
1701
CheckCanEnableWifi(void)1702 ErrCode WifiDeviceServiceImpl::CheckCanEnableWifi(void)
1703 {
1704 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1705 WIFI_LOGE("EnableWifi:VerifySetWifiInfoPermission PERMISSION_DENIED!");
1706 return WIFI_OPT_PERMISSION_DENIED;
1707 }
1708
1709 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED &&
1710 WifiPermissionUtils::VerifyEnterpriseWifiConnectionPermission() == PERMISSION_DENIED) {
1711 WIFI_LOGE("EnableWifi:VerifyWifiConnectionPermission PERMISSION_DENIED!");
1712 return WIFI_OPT_PERMISSION_DENIED;
1713 }
1714 #ifndef OHOS_ARCH_LITE
1715 if (WifiManager::GetInstance().GetWifiEventSubscriberManager()->IsMdmForbidden()) {
1716 WIFI_LOGE("EnableWifi: Mdm forbidden PERMISSION_DENIED!");
1717 return WIFI_OPT_ENTERPRISE_DENIED;
1718 }
1719 #endif
1720
1721 /**
1722 * when airplane mode opened, if the config "can_open_sta_when_airplanemode"
1723 * opened, then can open sta; other, return forbid.
1724 */
1725 if (WifiConfigCenter::GetInstance().GetAirplaneModeState() == MODE_STATE_OPEN &&
1726 !WifiSettings::GetInstance().GetCanOpenStaWhenAirplaneMode(m_instId)) {
1727 WIFI_LOGI("current airplane mode and can not use sta, open failed!");
1728 return WIFI_OPT_FORBID_AIRPLANE;
1729 }
1730 /* when power saving mode opened, can't open sta, return forbid. */
1731 if (WifiConfigCenter::GetInstance().GetPowerSavingModeState() == 1) {
1732 WIFI_LOGI("current power saving mode and can not use sta, open failed!");
1733 return WIFI_OPT_FORBID_POWSAVING;
1734 }
1735 #ifndef OHOS_ARCH_LITE
1736 if (WifiManager::GetInstance().GetWifiTogglerManager()->IsSatelliteStateStart()) {
1737 WIFI_LOGI("current satellite mode and can not use sta, open failed!");
1738 return WIFI_OPT_FORBID_AIRPLANE;
1739 }
1740 #endif
1741 /**
1742 * Check the interval between the last STA shutdown and the current STA
1743 * startup.
1744 */
1745 double interval = WifiConfigCenter::GetInstance().GetWifiStaInterval(m_instId);
1746 if (interval <= REOPEN_STA_INTERVAL) {
1747 int waitMils = REOPEN_STA_INTERVAL - int(interval) + 1;
1748 WIFI_LOGI("open wifi too frequent, interval since last close is %{public}lf, and wait %{public}d ms",
1749 interval,
1750 waitMils);
1751 usleep(waitMils * MSEC);
1752 }
1753 return WIFI_OPT_SUCCESS;
1754 }
1755
IsStaServiceRunning()1756 bool WifiDeviceServiceImpl::IsStaServiceRunning()
1757 {
1758 WifiOprMidState curState = WifiConfigCenter::GetInstance().GetWifiMidState(m_instId);
1759 if (curState != WifiOprMidState::RUNNING) {
1760 WIFI_LOGW("current wifi state is %{public}d, instId: %{public}d", static_cast<int>(curState), m_instId);
1761 return false;
1762 }
1763 return true;
1764 }
1765
IsScanServiceRunning()1766 bool WifiDeviceServiceImpl::IsScanServiceRunning()
1767 {
1768 WifiOprMidState curState = WifiConfigCenter::GetInstance().GetScanMidState(m_instId);
1769 if (curState != WifiOprMidState::RUNNING) {
1770 WIFI_LOGW("scan service does not started!");
1771 return false;
1772 }
1773 return true;
1774 }
1775
SaBasicDump(std::string & result)1776 void WifiDeviceServiceImpl::SaBasicDump(std::string& result)
1777 {
1778 WifiDeviceServiceImpl impl;
1779 bool isActive = impl.IsStaServiceRunning();
1780 result.append("WiFi active state: ");
1781 std::string strActive = isActive ? "activated" : "inactive";
1782 result += strActive + "\n\n";
1783
1784 WifiLinkedInfo linkedInfo;
1785 WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo);
1786 bool isConnected = linkedInfo.connState == ConnState::CONNECTED;
1787 result.append("WiFi connection status: ");
1788 std::string strIsConnected = isConnected ? "connected" : "not connected";
1789 result += strIsConnected + "\n";
1790 if (isConnected) {
1791 std::stringstream ss;
1792 ss << " Connection.ssid: " << linkedInfo.ssid << "\n";
1793 ss << " Connection.bssid: " << MacAnonymize(linkedInfo.bssid) << "\n";
1794 ss << " Connection.rssi: " << linkedInfo.rssi << "\n";
1795
1796 enum {BAND_2GHZ = 1, BAND_5GHZ = 2, BAND_6GHZ = 3, BAND_60GHZ = 4, BAND_ANY = 5};
1797 auto funcStrBand = [](int band) {
1798 std::string retStr;
1799 switch (band) {
1800 case BAND_2GHZ:
1801 retStr = "2.4GHz";
1802 break;
1803 case BAND_5GHZ:
1804 retStr = "5GHz";
1805 break;
1806 case BAND_ANY:
1807 retStr = "dual-mode frequency band";
1808 break;
1809 case BAND_6GHZ:
1810 retStr = "6GHz";
1811 break;
1812 case BAND_60GHZ:
1813 retStr = "60GHz";
1814 break;
1815 default:
1816 retStr = "unknown band";
1817 }
1818 return retStr;
1819 };
1820 ss << " Connection.band: " << funcStrBand(linkedInfo.band) << "\n";
1821 ss << " Connection.frequency: " << linkedInfo.frequency << "\n";
1822 ss << " Connection.linkSpeed: " << linkedInfo.linkSpeed << "\n";
1823 ss << " Connection.macAddress: " << MacAnonymize(linkedInfo.macAddress) << "\n";
1824 ss << " Connection.isHiddenSSID: " << (linkedInfo.ifHiddenSSID ? "true" : "false") << "\n";
1825
1826 int level = WifiSettings::GetInstance().GetSignalLevel(linkedInfo.rssi, linkedInfo.band);
1827 ss << " Connection.signalLevel: " << level << "\n";
1828 result += ss.str();
1829 }
1830 result += "\n";
1831
1832 std::string cc = "CN";
1833 #ifndef OHOS_ARCH_LITE
1834 WifiCountryCodeManager::GetInstance().GetWifiCountryCode(cc);
1835 #endif
1836 result.append("Country Code: ").append(cc);
1837 result += "\n";
1838 }
1839
GetChangeDeviceConfig(ConfigChange & value,WifiDeviceConfig & config)1840 ErrCode WifiDeviceServiceImpl::GetChangeDeviceConfig(ConfigChange& value, WifiDeviceConfig &config)
1841 {
1842 if (!WifiAuthCenter::IsSystemAccess()) {
1843 WIFI_LOGE("GetChangeDeviceConfig:NOT System APP, PERMISSION_DENIED!");
1844 return WIFI_OPT_NON_SYSTEMAPP;
1845 }
1846
1847 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1848 WIFI_LOGE("GetChangeDeviceConfig:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1849 return WIFI_OPT_PERMISSION_DENIED;
1850 }
1851 #ifndef SUPPORT_RANDOM_MAC_ADDR
1852 if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
1853 WIFI_LOGE("GetChangeDeviceConfig:VerifyGetScanInfosPermission() PERMISSION_DENIED!");
1854 return WIFI_OPT_PERMISSION_DENIED;
1855 }
1856 #endif
1857 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
1858 WIFI_LOGE("GetDeviceConfigs:VerifyGetWifiConfigPermission() PERMISSION_DENIED!");
1859 return WIFI_OPT_PERMISSION_DENIED;
1860 }
1861
1862 bool result = WifiConfigCenter::GetInstance().GetChangeDeviceConfig(value, config);
1863 if (!result) {
1864 WIFI_LOGE("WifiDeviceServiceImpl::GetChangeDeviceConfig failed!");
1865 return WIFI_OPT_FAILED;
1866 }
1867 return WIFI_OPT_SUCCESS;
1868 }
1869
IsRemoteDied(void)1870 bool WifiDeviceServiceImpl::IsRemoteDied(void)
1871 {
1872 return false;
1873 }
1874
IsBandTypeSupported(int bandType,bool & supported)1875 ErrCode WifiDeviceServiceImpl::IsBandTypeSupported(int bandType, bool &supported)
1876 {
1877 WIFI_LOGI("Enter get bandtype is supported.");
1878 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1879 WIFI_LOGE("IsBandTypeSupported:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1880 return WIFI_OPT_PERMISSION_DENIED;
1881 }
1882
1883 if (bandType <= (int)BandType::BAND_NONE || bandType >= (int)BandType::BAND_ANY) {
1884 WIFI_LOGE("IsBandTypeSupported bandType error %{public}d!", bandType);
1885 return WIFI_OPT_INVALID_PARAM;
1886 } else {
1887 ChannelsTable channels;
1888 WifiChannelHelper::GetInstance().GetValidChannels(channels);
1889 supported = channels.find((BandType)bandType) != channels.end();
1890 }
1891 return WIFI_OPT_SUCCESS;
1892 }
1893
Get5GHzChannelList(std::vector<int> & result)1894 ErrCode WifiDeviceServiceImpl::Get5GHzChannelList(std::vector<int> &result)
1895 {
1896 WIFI_LOGI("Enter get 5g channel list.");
1897 if (!WifiAuthCenter::IsSystemAccess()) {
1898 WIFI_LOGE("Get5GHzChannelList: NOT System APP, PERMISSION_DENIED!");
1899 return WIFI_OPT_NON_SYSTEMAPP;
1900 }
1901
1902 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1903 WIFI_LOGE("Get5GHzChannelList:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1904 return WIFI_OPT_PERMISSION_DENIED;
1905 }
1906
1907 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
1908 WIFI_LOGE("Get5GHzChannelList:VerifyGetWifiConfigPermission PERMISSION_DENIED!");
1909 return WIFI_OPT_PERMISSION_DENIED;
1910 }
1911
1912 ChannelsTable channels;
1913 WifiChannelHelper::GetInstance().GetValidChannels(channels);
1914 if (channels.find(BandType::BAND_5GHZ) != channels.end()) {
1915 result = channels[BandType::BAND_5GHZ];
1916 }
1917
1918 return WIFI_OPT_SUCCESS;
1919 }
1920
StartPortalCertification()1921 ErrCode WifiDeviceServiceImpl::StartPortalCertification()
1922 {
1923 WIFI_LOGI("Enter StartPortalCertification.");
1924 if (!WifiAuthCenter::IsSystemAccess()) {
1925 WIFI_LOGE("StartPortalCertification: NOT System APP, PERMISSION_DENIED!");
1926 return WIFI_OPT_NON_SYSTEMAPP;
1927 }
1928
1929 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1930 WIFI_LOGE("StartPortalCertification:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1931 return WIFI_OPT_PERMISSION_DENIED;
1932 }
1933
1934 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
1935 WIFI_LOGE("StartPortalCertification:VerifyGetWifiConfigPermission PERMISSION_DENIED!");
1936 return WIFI_OPT_PERMISSION_DENIED;
1937 }
1938
1939 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst();
1940 if (pService == nullptr) {
1941 WIFI_LOGE("pService is nullptr!");
1942 return WIFI_OPT_STA_NOT_OPENED;
1943 }
1944
1945 return pService->StartPortalCertification();
1946 }
1947
FactoryReset()1948 ErrCode WifiDeviceServiceImpl::FactoryReset()
1949 {
1950 WIFI_LOGI("Enter FactoryReset.");
1951 if (!WifiAuthCenter::IsSystemAccess()) {
1952 WIFI_LOGE("FactoryReset: NOT System APP, PERMISSION_DENIED!");
1953 return WIFI_OPT_NON_SYSTEMAPP;
1954 }
1955
1956 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1957 WIFI_LOGE("WifiDeviceServiceImpl:FactoryReset() PERMISSION_DENIED!");
1958 return WIFI_OPT_PERMISSION_DENIED;
1959 }
1960
1961 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
1962 WIFI_LOGE("WifiDeviceServiceImpl:FactoryReset() PERMISSION_DENIED!");
1963 return WIFI_OPT_PERMISSION_DENIED;
1964 }
1965
1966 WIFI_LOGI("WifiDeviceServiceImpl FactoryReset sta,p2p,hotspot! m_instId:%{public}d", m_instId);
1967 if (m_instId == INSTID_WLAN0 || m_instId == INSTID_WLAN1) {
1968 WifiConfigCenter::GetInstance().SetWifiToggledState(WIFI_STATE_SEMI_ENABLED, m_instId);
1969 #ifndef OHOS_ARCH_LITE
1970 WifiSettings::GetInstance().SetWifiToggleCaller(GetCallingPid(), m_instId);
1971 #endif
1972 }
1973 WifiManager::GetInstance().GetWifiTogglerManager()->StartSemiWifiToggledTimer();
1974 WifiManager::GetInstance().GetWifiTogglerManager()->WifiToggled(0, m_instId);
1975 WifiOprMidState curState = WifiConfigCenter::GetInstance().GetApMidState(m_instId);
1976 WIFI_LOGI("WifiDeviceServiceImpl curState:%{public}d", curState);
1977 if (curState == WifiOprMidState::RUNNING) {
1978 WifiManager::GetInstance().GetWifiTogglerManager()->SoftapToggled(0, m_instId);
1979 }
1980 // wifi device
1981 WifiSettings::GetInstance().ClearDeviceConfig();
1982 WifiSettings::GetInstance().SyncDeviceConfig();
1983 #ifndef OHOS_ARCH_LITE
1984 WifiHistoryRecordManager::GetInstance().DeleteAllApInfo();
1985 FactoryResetNotify();
1986 #endif
1987 #if defined(FEATURE_AUTOOPEN_SPEC_LOC_SUPPORT) && defined(FEATURE_WIFI_PRO_SUPPORT)
1988 IWifiProService *pWifiProService = WifiServiceManager::GetInstance().GetWifiProServiceInst(m_instId);
1989 if (pWifiProService != nullptr) {
1990 WifiDeviceConfig config;
1991 pWifiProService->OnWifiDeviceConfigChange(static_cast<int32_t>(ConfigChange::CONFIG_REMOVE), config, true);
1992 }
1993 #endif
1994 /* p2p */
1995 WifiSettings::GetInstance().RemoveWifiP2pGroupInfo();
1996 WifiSettings::GetInstance().SyncWifiP2pGroupInfoConfig();
1997 WifiSettings::GetInstance().RemoveWifiP2pSupplicantGroupInfo();
1998 /* Hotspot */
1999 WifiSettings::GetInstance().ClearHotspotConfig();
2000 WifiSettings::GetInstance().SyncHotspotConfig();
2001 WIFI_LOGI("WifiDeviceServiceImpl FactoryReset ok!");
2002 return WIFI_OPT_SUCCESS;
2003 }
2004
2005 #ifndef OHOS_ARCH_LITE
FactoryResetNotify()2006 ErrCode WifiDeviceServiceImpl::FactoryResetNotify()
2007 {
2008 WIFI_LOGI("Enter FactoryResetNotify.");
2009 IEnhanceService *pEnhanceService = WifiServiceManager::GetInstance().GetEnhanceServiceInst();
2010 if (pEnhanceService == nullptr) {
2011 WIFI_LOGE("%{public}s pEnhanceService is nullptr!", __FUNCTION__);
2012 return WIFI_OPT_FAILED;
2013 }
2014 pEnhanceService->ResetNetworkSettingsNotify();
2015 return WIFI_OPT_SUCCESS;
2016 }
2017 #endif
2018
ComparedHinlinkKeymgmt(const std::string scanInfoKeymgmt,const std::string deviceKeymgmt)2019 bool ComparedHinlinkKeymgmt(const std::string scanInfoKeymgmt, const std::string deviceKeymgmt)
2020 {
2021 if (deviceKeymgmt == "WPA-PSK") {
2022 return scanInfoKeymgmt.find("PSK") != std::string::npos;
2023 } else if (deviceKeymgmt == "WPA-EAP") {
2024 return scanInfoKeymgmt.find("EAP") != std::string::npos;
2025 } else if (deviceKeymgmt == "SAE") {
2026 return scanInfoKeymgmt.find("SAE") != std::string::npos;
2027 } else if (deviceKeymgmt == "NONE") {
2028 return (scanInfoKeymgmt.find("PSK") == std::string::npos) &&
2029 (scanInfoKeymgmt.find("EAP") == std::string::npos) && (scanInfoKeymgmt.find("SAE") == std::string::npos);
2030 } else {
2031 return false;
2032 }
2033 }
2034
HilinkGetMacAddress(WifiDeviceConfig & deviceConfig,std::string & currentMac)2035 ErrCode WifiDeviceServiceImpl::HilinkGetMacAddress(WifiDeviceConfig &deviceConfig, std::string ¤tMac)
2036 {
2037 #ifndef SUPPORT_LOCAL_RANDOM_MAC
2038 WifiSettings::GetInstance().GetRealMacAddress(currentMac, m_instId);
2039 #else
2040 if (deviceConfig.wifiPrivacySetting == WifiPrivacyConfig::DEVICEMAC) {
2041 WifiSettings::GetInstance().GetRealMacAddress(currentMac, m_instId);
2042 } else {
2043 WifiStoreRandomMac randomMacInfo;
2044 std::vector<WifiScanInfo> scanInfoList;
2045 WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(scanInfoList);
2046 for (auto scanInfo : scanInfoList) {
2047 if ((deviceConfig.ssid == scanInfo.ssid) &&
2048 (ComparedHinlinkKeymgmt(scanInfo.capabilities, deviceConfig.keyMgmt))) {
2049 randomMacInfo.ssid = scanInfo.ssid;
2050 randomMacInfo.keyMgmt = deviceConfig.keyMgmt;
2051 randomMacInfo.preSharedKey = deviceConfig.preSharedKey;
2052 randomMacInfo.peerBssid = scanInfo.bssid;
2053 break;
2054 }
2055 }
2056 if (randomMacInfo.ssid.empty()) {
2057 LOGE("EnableHiLinkHandshake scanInfo has no target wifi!");
2058 return WIFI_OPT_FAILED;
2059 }
2060
2061 WifiSettings::GetInstance().GetRandomMac(randomMacInfo);
2062 if (randomMacInfo.randomMac.empty()) {
2063 /* Sets the MAC address of WifiSettings. */
2064 std::string macAddress;
2065 std::string deviceConfigKey = randomMacInfo.ssid + randomMacInfo.keyMgmt;
2066 int ret = WifiRandomMacHelper::CalculateRandomMacForWifiDeviceConfig(deviceConfigKey, macAddress);
2067 if (ret != 0) {
2068 ret = WifiRandomMacHelper::CalculateRandomMacForWifiDeviceConfig(deviceConfigKey, macAddress);
2069 }
2070 if (ret != 0) {
2071 WIFI_LOGI("HilinkGetMacAddress Failed to generate MAC address, Using locally generated MAC.");
2072 WifiRandomMacHelper::GenerateRandomMacAddress(macAddress);
2073 }
2074 randomMacInfo.randomMac = macAddress;
2075 LOGI("%{public}s: generate a random mac, randomMac:%{public}s, ssid:%{public}s, peerbssid:%{public}s",
2076 __func__, MacAnonymize(randomMacInfo.randomMac).c_str(), SsidAnonymize(randomMacInfo.ssid).c_str(),
2077 MacAnonymize(randomMacInfo.peerBssid).c_str());
2078 WifiSettings::GetInstance().AddRandomMac(randomMacInfo);
2079 } else {
2080 LOGI("%{public}s: randomMac:%{public}s, ssid:%{public}s, peerbssid:%{public}s",
2081 __func__, MacAnonymize(randomMacInfo.randomMac).c_str(), SsidAnonymize(randomMacInfo.ssid).c_str(),
2082 MacAnonymize(randomMacInfo.peerBssid).c_str());
2083 }
2084 currentMac = randomMacInfo.randomMac;
2085 }
2086 WIFI_LOGI("EnableHiLinkHandshake mac address get success, mac = %{public}s", MacAnonymize(currentMac).c_str());
2087 #endif
2088 return WIFI_OPT_SUCCESS;
2089 }
2090
EnableHiLinkHandshake(bool uiFlag,std::string & bssid,WifiDeviceConfig & deviceConfig)2091 ErrCode WifiDeviceServiceImpl::EnableHiLinkHandshake(bool uiFlag, std::string &bssid, WifiDeviceConfig &deviceConfig)
2092 {
2093 WIFI_LOGI("EnableHiLinkHandshake enter");
2094 if (!WifiAuthCenter::IsSystemAccess()) {
2095 WIFI_LOGE("EnableHiLinkHandshake: NOT System APP, PERMISSION_DENIED!");
2096 return WIFI_OPT_NON_SYSTEMAPP;
2097 }
2098 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
2099 WIFI_LOGE("EnableHiLinkHandshake:VerifySetWifiInfoPermission PERMISSION_DENIED!");
2100 return WIFI_OPT_PERMISSION_DENIED;
2101 }
2102
2103 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
2104 WIFI_LOGE("EnableHiLinkHandshake:VerifyWifiConnectionPermission PERMISSION_DENIED!");
2105 return WIFI_OPT_PERMISSION_DENIED;
2106 }
2107 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst();
2108 if (pService == nullptr) {
2109 WIFI_LOGE("pService is nullptr!");
2110 return WIFI_OPT_STA_NOT_OPENED;
2111 }
2112 char cmd[HILINK_CMD_MAX_LEN] = {0};
2113 if (!uiFlag) {
2114 if (sprintf_s(cmd, sizeof(cmd), "ENABLE=%d BSSID=%s", uiFlag, bssid.c_str()) < 0) {
2115 WIFI_LOGE("uiFlag false copy enable and bssid error!");
2116 return WIFI_OPT_FAILED;
2117 }
2118 g_hiLinkActive = uiFlag;
2119 pService->EnableHiLinkHandshake(uiFlag, deviceConfig, cmd);
2120 return WIFI_OPT_SUCCESS;
2121 }
2122 if (!g_hiLinkActive) {
2123 if (sprintf_s(cmd, sizeof(cmd), "ENABLE=%d BSSID=%s", uiFlag, bssid.c_str()) < 0) {
2124 WIFI_LOGE("g_hiLinkActive copy enable and bssid error!");
2125 return WIFI_OPT_FAILED;
2126 }
2127 pService->EnableHiLinkHandshake(uiFlag, deviceConfig, cmd);
2128 }
2129
2130 std::string currentMac;
2131 if (HilinkGetMacAddress(deviceConfig, currentMac) != WIFI_OPT_SUCCESS) {
2132 return WIFI_OPT_FAILED;
2133 }
2134 g_hiLinkActive = uiFlag;
2135
2136 if (memset_s(cmd, sizeof(cmd), 0x0, sizeof(cmd)) != EOK) {
2137 WIFI_LOGE("g_hiLinkActive memset_s error!");
2138 return WIFI_OPT_FAILED;
2139 }
2140 if (sprintf_s(cmd, sizeof(cmd), "HILINK_MAC=%s", currentMac.c_str()) < 0) {
2141 WIFI_LOGE("g_hiLinkActive copy mac error!");
2142 return WIFI_OPT_FAILED;
2143 }
2144 pService->DeliverStaIfaceData(cmd);
2145
2146 WIFI_LOGI("WifiDeviceServiceImpl EnableHiLinkHandshake ok!");
2147 return WIFI_OPT_SUCCESS;
2148 }
2149
2150 #ifndef OHOS_ARCH_LITE
ReceiveNetworkControlInfo(const WifiNetworkControlInfo & networkControlInfo)2151 ErrCode WifiDeviceServiceImpl::ReceiveNetworkControlInfo(const WifiNetworkControlInfo& networkControlInfo)
2152 {
2153 WIFI_LOGD("Enter ReceiveNetworkControlInfo.");
2154 if (!WifiAuthCenter::IsNativeProcess()) {
2155 WIFI_LOGE("%{public}s NOT NATIVE PROCESS, PERMISSION_DENIED!", __FUNCTION__);
2156 return WIFI_OPT_NON_SYSTEMAPP;
2157 }
2158 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2159 WIFI_LOGE("%{public}s PERMISSION_DENIED!", __FUNCTION__);
2160 return WIFI_OPT_PERMISSION_DENIED;
2161 }
2162 int callingUid = GetCallingUid();
2163 if (callingUid != RSS_UID) {
2164 WIFI_LOGE("%{public}s This interface is only for RSS, and uid: %{public}d can't be called!",
2165 __FUNCTION__, callingUid);
2166 return WIFI_OPT_FAILED;
2167 }
2168 AppNetworkSpeedLimitService::GetInstance().ReceiveNetworkControlInfo(networkControlInfo);
2169 return WIFI_OPT_SUCCESS;
2170 }
2171
LimitSpeed(const int controlId,const int limitMode)2172 ErrCode WifiDeviceServiceImpl::LimitSpeed(const int controlId, const int limitMode)
2173 {
2174 #ifndef OHOS_ARCH_LITE
2175 WIFI_LOGD("%{public}s enter, pid:%{public}d, uid:%{public}d, BundleName:%{public}s.",
2176 __FUNCTION__, GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
2177 #endif
2178 WIFI_LOGD("Enter LimitSpeed.");
2179 if (!WifiAuthCenter::IsNativeProcess()) {
2180 WIFI_LOGE("%{public}s NOT NATIVE PROCESS, PERMISSION_DENIED!", __FUNCTION__);
2181 return WIFI_OPT_NON_SYSTEMAPP;
2182 }
2183 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2184 WIFI_LOGE("%{public}s PERMISSION_DENIED!", __FUNCTION__);
2185 return WIFI_OPT_PERMISSION_DENIED;
2186 }
2187 AppNetworkSpeedLimitService::GetInstance().LimitSpeed(controlId, limitMode);
2188 return WIFI_OPT_SUCCESS;
2189 }
2190
SetLowTxPower(const WifiLowPowerParam wifiLowPowerParam)2191 ErrCode WifiDeviceServiceImpl::SetLowTxPower(const WifiLowPowerParam wifiLowPowerParam)
2192 {
2193 WIFI_LOGI("%{public}s enter, pid:%{public}d, uid:%{public}d",
2194 __FUNCTION__, GetCallingPid(), GetCallingUid());
2195 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2196 WIFI_LOGE("%{public}s PERMISSION_DENIED!", __FUNCTION__);
2197 return WIFI_OPT_PERMISSION_DENIED;
2198 }
2199 IEnhanceService *pEnhanceService = WifiServiceManager::GetInstance().GetEnhanceServiceInst();
2200 if (pEnhanceService == nullptr) {
2201 WIFI_LOGE("%{public}s pEnhanceService is nullptr!", __FUNCTION__);
2202 return WIFI_OPT_FAILED;
2203 }
2204 if (pEnhanceService->SetLowTxPower(wifiLowPowerParam)) {
2205 WIFI_LOGE("%{public}s set low tx power fail!", __FUNCTION__);
2206 return WIFI_OPT_FAILED;
2207 }
2208 return WIFI_OPT_SUCCESS;
2209 }
2210
SetAppFrozen(std::set<int> pidList,bool isFrozen)2211 ErrCode WifiDeviceServiceImpl::SetAppFrozen(std::set<int> pidList, bool isFrozen)
2212 {
2213 if (!WifiAuthCenter::IsNativeProcess()) {
2214 WIFI_LOGE("SetAppFrozen:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2215 return WIFI_OPT_PERMISSION_DENIED;
2216 }
2217 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
2218 WIFI_LOGE("WifiDeviceServiceImpl:SetAppFrozen() PERMISSION_DENIED!");
2219 return WIFI_OPT_PERMISSION_DENIED;
2220 }
2221 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2222 WIFI_LOGE("WifiDeviceServiceImpl:SetAppFrozen() PERMISSION_DENIED!");
2223 return WIFI_OPT_PERMISSION_DENIED;
2224 }
2225 WifiInternalEventDispatcher::GetInstance().SetAppFrozen(pidList, isFrozen);
2226 return WIFI_OPT_SUCCESS;
2227 }
2228
ResetAllFrozenApp()2229 ErrCode WifiDeviceServiceImpl::ResetAllFrozenApp()
2230 {
2231 if (!WifiAuthCenter::IsNativeProcess()) {
2232 WIFI_LOGE("ResetAllFrozenApp:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2233 return WIFI_OPT_PERMISSION_DENIED;
2234 }
2235 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
2236 WIFI_LOGE("WifiDeviceServiceImpl:ResetAllFrozenApp() PERMISSION_DENIED!");
2237 return WIFI_OPT_PERMISSION_DENIED;
2238 }
2239 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2240 WIFI_LOGE("WifiDeviceServiceImpl:ResetAllFrozenApp() PERMISSION_DENIED!");
2241 return WIFI_OPT_PERMISSION_DENIED;
2242 }
2243 WifiInternalEventDispatcher::GetInstance().ResetAllFrozenApp();
2244 return WIFI_OPT_SUCCESS;
2245 }
2246
DisableAutoJoin(const std::string & conditionName)2247 ErrCode WifiDeviceServiceImpl::DisableAutoJoin(const std::string &conditionName)
2248 {
2249 if (!WifiAuthCenter::IsSystemAccess()) {
2250 WIFI_LOGE("DisableAutoJoin:NOT System APP, PERMISSION_DENIED!");
2251 return WIFI_OPT_PERMISSION_DENIED;
2252 }
2253 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2254 if (pService == nullptr) {
2255 WIFI_LOGE("pService is nullptr!");
2256 return WIFI_OPT_STA_NOT_OPENED;
2257 }
2258 return pService->DisableAutoJoin(conditionName);
2259 }
2260
EnableAutoJoin(const std::string & conditionName)2261 ErrCode WifiDeviceServiceImpl::EnableAutoJoin(const std::string &conditionName)
2262 {
2263 if (!WifiAuthCenter::IsSystemAccess()) {
2264 WIFI_LOGE("EnableAutoJoin:NOT System APP, PERMISSION_DENIED!");
2265 return WIFI_OPT_PERMISSION_DENIED;
2266 }
2267 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2268 if (pService == nullptr) {
2269 WIFI_LOGE("pService is nullptr!");
2270 return WIFI_OPT_STA_NOT_OPENED;
2271 }
2272 return pService->EnableAutoJoin(conditionName);
2273 }
2274
RegisterAutoJoinCondition(const std::string & conditionName,const std::function<bool ()> & autoJoinCondition)2275 ErrCode WifiDeviceServiceImpl::RegisterAutoJoinCondition(const std::string &conditionName,
2276 const std::function<bool()> &autoJoinCondition)
2277 {
2278 if (!WifiAuthCenter::IsNativeProcess()) {
2279 WIFI_LOGE("RegisterAutoJoinCondition:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2280 return WIFI_OPT_PERMISSION_DENIED;
2281 }
2282 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2283 WIFI_LOGE("RegisterAutoJoinCondition:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2284 return WIFI_OPT_PERMISSION_DENIED;
2285 }
2286 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2287 if (pService == nullptr) {
2288 WIFI_LOGE("pService is nullptr!");
2289 return WIFI_OPT_STA_NOT_OPENED;
2290 }
2291 return pService->RegisterAutoJoinCondition(conditionName, autoJoinCondition);
2292 }
2293
DeregisterAutoJoinCondition(const std::string & conditionName)2294 ErrCode WifiDeviceServiceImpl::DeregisterAutoJoinCondition(const std::string &conditionName)
2295 {
2296 if (!WifiAuthCenter::IsNativeProcess()) {
2297 WIFI_LOGE("DeregisterAutoJoinCondition:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2298 return WIFI_OPT_PERMISSION_DENIED;
2299 }
2300 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2301 WIFI_LOGE("DeregisterAutoJoinCondition:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2302 return WIFI_OPT_PERMISSION_DENIED;
2303 }
2304 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2305 if (pService == nullptr) {
2306 WIFI_LOGE("pService is nullptr!");
2307 return WIFI_OPT_STA_NOT_OPENED;
2308 }
2309 return pService->DeregisterAutoJoinCondition(conditionName);
2310 }
2311
RegisterFilterBuilder(const FilterTag & filterTag,const std::string & builderName,const FilterBuilder & filterBuilder)2312 ErrCode WifiDeviceServiceImpl::RegisterFilterBuilder(const FilterTag &filterTag,
2313 const std::string &builderName,
2314 const FilterBuilder &filterBuilder)
2315 {
2316 if (!WifiAuthCenter::IsNativeProcess()) {
2317 WIFI_LOGE("RegisterFilterBuilder:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2318 return WIFI_OPT_PERMISSION_DENIED;
2319 }
2320 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2321 WIFI_LOGE("RegisterFilterBuilder:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2322 return WIFI_OPT_PERMISSION_DENIED;
2323 }
2324 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2325 if (pService == nullptr) {
2326 WIFI_LOGE("pService is nullptr!");
2327 return WIFI_OPT_STA_NOT_OPENED;
2328 }
2329 return pService->RegisterFilterBuilder(filterTag, builderName, filterBuilder);
2330 }
2331
DeregisterFilterBuilder(const FilterTag & filterTag,const std::string & builderName)2332 ErrCode WifiDeviceServiceImpl::DeregisterFilterBuilder(const FilterTag &filterTag,
2333 const std::string &builderName)
2334 {
2335 if (!WifiAuthCenter::IsNativeProcess()) {
2336 WIFI_LOGE("DeregisterFilterBuilder:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2337 return WIFI_OPT_PERMISSION_DENIED;
2338 }
2339 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2340 WIFI_LOGE("DeregisterFilterBuilder:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2341 return WIFI_OPT_PERMISSION_DENIED;
2342 }
2343 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2344 if (pService == nullptr) {
2345 WIFI_LOGE("pService is nullptr!");
2346 return WIFI_OPT_STA_NOT_OPENED;
2347 }
2348 return pService->DeregisterFilterBuilder(filterTag, builderName);
2349 }
2350
RegisterCommonBuilder(const TagType & tagType,const std::string & tagName,const CommonBuilder & commonBuilder)2351 ErrCode WifiDeviceServiceImpl::RegisterCommonBuilder(const TagType &tagType, const std::string &tagName,
2352 const CommonBuilder &commonBuilder)
2353 {
2354 if (!WifiAuthCenter::IsNativeProcess()) {
2355 WIFI_LOGE("RegisterFilterBuilder:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2356 return WIFI_OPT_PERMISSION_DENIED;
2357 }
2358 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2359 WIFI_LOGE("RegisterFilterBuilder:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2360 return WIFI_OPT_PERMISSION_DENIED;
2361 }
2362 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2363 if (pService == nullptr) {
2364 WIFI_LOGE("pService is nullptr!");
2365 return WIFI_OPT_STA_NOT_OPENED;
2366 }
2367 return pService->RegisterCommonBuilder(tagType, tagName, commonBuilder);
2368 }
2369
DeregisterCommonBuilder(const TagType & tagType,const std::string & tagName)2370 ErrCode WifiDeviceServiceImpl::DeregisterCommonBuilder(const TagType &tagType, const std::string &tagName)
2371 {
2372 if (!WifiAuthCenter::IsNativeProcess()) {
2373 WIFI_LOGE("DeregisterFilterBuilder:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2374 return WIFI_OPT_PERMISSION_DENIED;
2375 }
2376 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2377 WIFI_LOGE("DeregisterFilterBuilder:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2378 return WIFI_OPT_PERMISSION_DENIED;
2379 }
2380 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2381 if (pService == nullptr) {
2382 WIFI_LOGE("pService is nullptr!");
2383 return WIFI_OPT_STA_NOT_OPENED;
2384 }
2385 return pService->DeregisterCommonBuilder(tagType, tagName);
2386 }
2387
SetSatelliteState(const int state)2388 ErrCode WifiDeviceServiceImpl::SetSatelliteState(const int state)
2389 {
2390 WIFI_LOGI("Enter SetSatelliteState");
2391
2392 if (!WifiAuthCenter::IsSystemAccess()) {
2393 WIFI_LOGE("SetSatelliteState:NOT System APP, PERMISSION_DENIED!");
2394 return WIFI_OPT_NON_SYSTEMAPP;
2395 }
2396 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
2397 WIFI_LOGE("SetSatelliteState:VerifySetWifiInfoPermission PERMISSION_DENIED!");
2398 return WIFI_OPT_PERMISSION_DENIED;
2399 }
2400 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
2401 WIFI_LOGE("SetSatelliteState:VerifyWifiConnectionPermission PERMISSION_DENIED!");
2402 return WIFI_OPT_PERMISSION_DENIED;
2403 }
2404
2405 return WifiManager::GetInstance().GetWifiTogglerManager()->SatelliteToggled(state);
2406 }
2407
OnBackup(MessageParcel & data,MessageParcel & reply)2408 ErrCode WifiDeviceServiceImpl::OnBackup(MessageParcel& data, MessageParcel& reply)
2409 {
2410 UniqueFd fd(-1);
2411 std::string replyCode = WifiSettings::GetInstance().SetBackupReplyCode(0);
2412 std::string backupInfo = data.ReadString();
2413 int ret = WifiSettings::GetInstance().OnBackup(fd, backupInfo);
2414 std::fill(backupInfo.begin(), backupInfo.end(), 0);
2415 if (ret < 0) {
2416 WIFI_LOGE("OnBackup fail: backup data fail!");
2417 replyCode = WifiSettings::GetInstance().SetBackupReplyCode(EXTENSION_ERROR_CODE);
2418 }
2419 if (reply.WriteFileDescriptor(fd) == false || reply.WriteString(replyCode) == false) {
2420 close(fd.Release());
2421 WifiSettings::GetInstance().RemoveBackupFile();
2422 WIFI_LOGE("OnBackup fail: reply write fail!");
2423 return WIFI_OPT_FAILED;
2424 }
2425 close(fd.Release());
2426 WifiSettings::GetInstance().RemoveBackupFile();
2427 return WIFI_OPT_SUCCESS;
2428 }
2429
OnRestore(MessageParcel & data,MessageParcel & reply)2430 ErrCode WifiDeviceServiceImpl::OnRestore(MessageParcel& data, MessageParcel& reply)
2431 {
2432 UniqueFd fd(data.ReadFileDescriptor());
2433 std::string replyCode = WifiSettings::GetInstance().SetBackupReplyCode(0);
2434 std::string restoreInfo = data.ReadString();
2435 int ret = WifiSettings::GetInstance().OnRestore(fd, restoreInfo);
2436 std::fill(restoreInfo.begin(), restoreInfo.end(), 0);
2437 if (ret < 0) {
2438 WIFI_LOGE("OnRestore fail: restore data fail!");
2439 replyCode = WifiSettings::GetInstance().SetBackupReplyCode(EXTENSION_ERROR_CODE);
2440 }
2441 if (reply.WriteString(replyCode) == false) {
2442 close(fd.Release());
2443 WifiSettings::GetInstance().RemoveBackupFile();
2444 WIFI_LOGE("OnRestore fail: reply write fail!");
2445 return WIFI_OPT_FAILED;
2446 }
2447 close(fd.Release());
2448 WifiSettings::GetInstance().RemoveBackupFile();
2449 return WIFI_OPT_SUCCESS;
2450 }
2451 #endif
2452
ProcessPermissionVerify(const std::string & appId,const std::string & packageName)2453 int WifiDeviceServiceImpl::ProcessPermissionVerify(const std::string &appId, const std::string &packageName)
2454 {
2455 if (appId.empty() || packageName.empty()) {
2456 WIFI_LOGD("ProcessPermissionVerify(), PERMISSION_DENIED");
2457 return PERMISSION_DENIED;
2458 }
2459 std::map<std::string, std::vector<PackageInfo>> packageInfoMap;
2460 if (WifiSettings::GetInstance().GetPackageInfoMap(packageInfoMap) != 0) {
2461 WIFI_LOGE("WifiSettings::GetInstance().GetPackageInfoMap failed");
2462 return PERMISSION_DENIED;
2463 }
2464 std::vector<PackageInfo> whilteListProcessInfo = packageInfoMap["AclAuthPackages"];
2465 auto iter = whilteListProcessInfo.begin();
2466 while (iter != whilteListProcessInfo.end()) {
2467 if (iter->name == packageName && iter->appid == appId) {
2468 return PERMISSION_GRANTED;
2469 }
2470 iter++;
2471 }
2472 return PERMISSION_DENIED;
2473 }
2474
UpdateNetworkLagInfo(const NetworkLagType networkLagType,const NetworkLagInfo & networkLagInfo)2475 ErrCode WifiDeviceServiceImpl::UpdateNetworkLagInfo(const NetworkLagType networkLagType,
2476 const NetworkLagInfo &networkLagInfo)
2477 {
2478 // permission check
2479 #ifndef OHOS_ARCH_LITE
2480 WIFI_LOGD("UpdateNetworkLagInfo, uid:%{public}d.", GetCallingUid());
2481 #endif
2482
2483 if (!WifiAuthCenter::IsNativeProcess()) {
2484 WIFI_LOGE("UpdateNetworkLagInfo:NOT NATIVE PROCESS, PERMISSION_DENIED!");
2485 return WIFI_OPT_PERMISSION_DENIED;
2486 }
2487
2488 // date distribute
2489 ErrCode ret = WIFI_OPT_SUCCESS;
2490 #ifdef FEATURE_WIFI_PRO_SUPPORT
2491 IWifiProService *pWifiProService = WifiServiceManager::GetInstance().GetWifiProServiceInst(m_instId);
2492 if (pWifiProService == nullptr) {
2493 return WIFI_OPT_FAILED;
2494 }
2495 pWifiProService->DealQoeReport(networkLagType, networkLagInfo);
2496 #endif
2497 return ret;
2498 }
2499
FetchWifiSignalInfoForVoWiFi(VoWifiSignalInfo & signalInfo)2500 ErrCode WifiDeviceServiceImpl::FetchWifiSignalInfoForVoWiFi(VoWifiSignalInfo &signalInfo)
2501 {
2502 #ifdef FEATURE_VOWIFI_SUPPORT
2503 if (!WifiAuthCenter::IsNativeProcess()) {
2504 WIFI_LOGE("FetchWifiSignalInfoForVoWiFi: NOT NATIVE PROCESS, PERMISSION_DENIED!");
2505 return WIFI_OPT_NON_SYSTEMAPP;
2506 }
2507 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
2508 WIFI_LOGE("FetchWifiSignalInfoForVoWiFi:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
2509 return WIFI_OPT_PERMISSION_DENIED;
2510 }
2511 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
2512 WIFI_LOGE("FetchWifiSignalInfoForVoWiFi:VerifyGetWifiConfigPermission PERMISSION_DENIED!");
2513 return WIFI_OPT_PERMISSION_DENIED;
2514 }
2515 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2516 if (pService == nullptr) {
2517 WIFI_LOGE("pService is nullptr!");
2518 return WIFI_OPT_STA_NOT_OPENED;
2519 }
2520 return pService->FetchWifiSignalInfoForVoWiFi(signalInfo);
2521 #else
2522 return WIFI_OPT_SUCCESS;
2523 #endif
2524 }
2525
IsSupportVoWifiDetect(bool & isSupported)2526 ErrCode WifiDeviceServiceImpl::IsSupportVoWifiDetect(bool &isSupported)
2527 {
2528 #ifdef FEATURE_VOWIFI_SUPPORT
2529 if (!WifiAuthCenter::IsNativeProcess()) {
2530 WIFI_LOGE("IsSupportVoWifiDetect: NOT NATIVE PROCESS, PERMISSION_DENIED!");
2531 return WIFI_OPT_NON_SYSTEMAPP;
2532 }
2533 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
2534 WIFI_LOGE("IsSupportVoWifiDetect:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
2535 return WIFI_OPT_PERMISSION_DENIED;
2536 }
2537 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
2538 WIFI_LOGE("IsSupportVoWifiDetect:VerifyGetWifiConfigPermission PERMISSION_DENIED!");
2539 return WIFI_OPT_PERMISSION_DENIED;
2540 }
2541 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2542 if (pService == nullptr) {
2543 WIFI_LOGE("pService is nullptr!");
2544 return WIFI_OPT_STA_NOT_OPENED;
2545 }
2546 return pService->IsSupportVoWifiDetect(isSupported);
2547 #else
2548 return WIFI_OPT_SUCCESS;
2549 #endif
2550 }
2551
SetVoWifiDetectMode(WifiDetectConfInfo info)2552 ErrCode WifiDeviceServiceImpl::SetVoWifiDetectMode(WifiDetectConfInfo info)
2553 {
2554 #ifdef FEATURE_VOWIFI_SUPPORT
2555 if (!WifiAuthCenter::IsNativeProcess()) {
2556 WIFI_LOGE("SetVoWifiDetectMode: NOT NATIVE PROCESS, PERMISSION_DENIED!");
2557 return WIFI_OPT_NON_SYSTEMAPP;
2558 }
2559 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
2560 WIFI_LOGE("SetVoWifiDetectMode:VerifySetWifiInfoPermission PERMISSION_DENIED!");
2561 return WIFI_OPT_PERMISSION_DENIED;
2562 }
2563 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2564 WIFI_LOGE("SetVoWifiDetectMode:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2565 return WIFI_OPT_PERMISSION_DENIED;
2566 }
2567 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2568 if (pService == nullptr) {
2569 WIFI_LOGE("pService is nullptr!");
2570 return WIFI_OPT_STA_NOT_OPENED;
2571 }
2572 return pService->SetVoWifiDetectMode(info);
2573 #else
2574 return WIFI_OPT_SUCCESS;
2575 #endif
2576 }
2577
GetVoWifiDetectMode(WifiDetectConfInfo & info)2578 ErrCode WifiDeviceServiceImpl::GetVoWifiDetectMode(WifiDetectConfInfo &info)
2579 {
2580 #ifdef FEATURE_VOWIFI_SUPPORT
2581 if (!WifiAuthCenter::IsNativeProcess()) {
2582 WIFI_LOGE("GetVoWifiDetectMode: NOT NATIVE PROCESS, PERMISSION_DENIED!");
2583 return WIFI_OPT_NON_SYSTEMAPP;
2584 }
2585 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
2586 WIFI_LOGE("GetVoWifiDetectMode:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
2587 return WIFI_OPT_PERMISSION_DENIED;
2588 }
2589 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
2590 WIFI_LOGE("GetVoWifiDetectMode:VerifyGetWifiConfigPermission PERMISSION_DENIED!");
2591 return WIFI_OPT_PERMISSION_DENIED;
2592 }
2593 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2594 if (pService == nullptr) {
2595 WIFI_LOGE("pService is nullptr!");
2596 return WIFI_OPT_STA_NOT_OPENED;
2597 }
2598 return pService->GetVoWifiDetectMode(info);
2599 #else
2600 return WIFI_OPT_SUCCESS;
2601 #endif
2602 }
2603
SetVoWifiDetectPeriod(int period)2604 ErrCode WifiDeviceServiceImpl::SetVoWifiDetectPeriod(int period)
2605 {
2606 #ifdef FEATURE_VOWIFI_SUPPORT
2607 if (!WifiAuthCenter::IsNativeProcess()) {
2608 WIFI_LOGE("SetVoWifiDetectPeriod: NOT NATIVE PROCESS, PERMISSION_DENIED!");
2609 return WIFI_OPT_NON_SYSTEMAPP;
2610 }
2611 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
2612 WIFI_LOGE("SetVoWifiDetectPeriod:VerifySetWifiInfoPermission PERMISSION_DENIED!");
2613 return WIFI_OPT_PERMISSION_DENIED;
2614 }
2615 if (WifiPermissionUtils::VerifySetWifiConfigPermission() == PERMISSION_DENIED) {
2616 WIFI_LOGE("SetVoWifiDetectPeriod:VerifySetWifiConfigPermission PERMISSION_DENIED!");
2617 return WIFI_OPT_PERMISSION_DENIED;
2618 }
2619 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2620 if (pService == nullptr) {
2621 WIFI_LOGE("pService is nullptr!");
2622 return WIFI_OPT_STA_NOT_OPENED;
2623 }
2624 return pService->SetVoWifiDetectPeriod(period);
2625 #else
2626 return WIFI_OPT_SUCCESS;
2627 #endif
2628 }
2629
GetVoWifiDetectPeriod(int & period)2630 ErrCode WifiDeviceServiceImpl::GetVoWifiDetectPeriod(int &period)
2631 {
2632 #ifdef FEATURE_VOWIFI_SUPPORT
2633 if (!WifiAuthCenter::IsNativeProcess()) {
2634 WIFI_LOGE("GetVoWifiDetectPeriod: NOT NATIVE PROCESS, PERMISSION_DENIED!");
2635 return WIFI_OPT_NON_SYSTEMAPP;
2636 }
2637 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
2638 WIFI_LOGE("GetVoWifiDetectPeriod:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
2639 return WIFI_OPT_PERMISSION_DENIED;
2640 }
2641 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
2642 WIFI_LOGE("GetVoWifiDetectPeriod:VerifyGetWifiConfigPermission PERMISSION_DENIED!");
2643 return WIFI_OPT_PERMISSION_DENIED;
2644 }
2645 IStaService *pService = WifiServiceManager::GetInstance().GetStaServiceInst(m_instId);
2646 if (pService == nullptr) {
2647 WIFI_LOGE("pService is nullptr!");
2648 return WIFI_OPT_STA_NOT_OPENED;
2649 }
2650 return pService->GetVoWifiDetectPeriod(period);
2651 #else
2652 return WIFI_OPT_SUCCESS;
2653 #endif
2654 }
2655
2656 #ifdef DYNAMIC_UNLOAD_SA
StopUnloadStaTimer(void)2657 void WifiDeviceServiceImpl::StopUnloadStaTimer(void)
2658 {
2659 WifiManager::GetInstance().GetWifiStaManager()->StopUnloadStaSaTimer();
2660 }
2661 #endif
2662
IsDisableWifiProhibitedByEdm(void)2663 bool WifiDeviceServiceImpl::IsDisableWifiProhibitedByEdm(void)
2664 {
2665 constexpr const char* WIFI_EDM_FORCE_OPEN_KEY = "persist.edm.force_open_wifi";
2666 constexpr const uint32_t PARAM_TRUE_LEN = 4;
2667 constexpr const uint32_t PARAM_FALSE_LEN = 5;
2668 constexpr const char* PARAM_TRUE = "true";
2669 constexpr const char* PARAM_FALSE = "false";
2670
2671 char preValue[PARAM_FALSE_LEN] = {0};
2672 int errCode = GetParamValue(WIFI_EDM_FORCE_OPEN_KEY, PARAM_FALSE, preValue, PARAM_FALSE_LEN);
2673 if (errCode > 0) {
2674 if (strncmp(preValue, PARAM_TRUE, PARAM_TRUE_LEN) == 0) {
2675 return true;
2676 }
2677 }
2678 return false;
2679 }
2680 } // namespace Wifi
2681 } // namespace OHOS
2682