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