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