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_p2p_service_impl.h"
17 #include <file_ex.h>
18 #include "define.h"
19 #include "if_config.h"
20 #include "ip_tools.h"
21 #include "wifi_auth_center.h"
22 #include "wifi_channel_helper.h"
23 #include "wifi_common_util.h"
24 #include "wifi_config_center.h"
25 #include "wifi_dumper.h"
26 #include "wifi_hid2d_service_utils.h"
27 #include "wifi_internal_event_dispatcher.h"
28 #include "wifi_logger.h"
29 #include "wifi_manager.h"
30 #include "wifi_net_agent.h"
31 #include "wifi_permission_utils.h"
32 #include "wifi_service_manager.h"
33 #include "wifi_global_func.h"
34 #include "mac_address.h"
35 #include "p2p_define.h"
36 #include "wifi_hisysevent.h"
37
38 DEFINE_WIFILOG_P2P_LABEL("WifiP2pServiceImpl");
39
40 namespace OHOS {
41 namespace Wifi {
42 std::mutex WifiP2pServiceImpl::instanceLock;
43 sptr<WifiP2pServiceImpl> WifiP2pServiceImpl::instance;
44 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(WifiP2pServiceImpl::GetInstance().GetRefPtr());
45
GetInstance()46 sptr<WifiP2pServiceImpl> WifiP2pServiceImpl::GetInstance()
47 {
48 if (instance == nullptr) {
49 std::lock_guard<std::mutex> autoLock(instanceLock);
50 if (instance == nullptr) {
51 sptr<WifiP2pServiceImpl> service = new (std::nothrow) WifiP2pServiceImpl;
52 instance = service;
53 }
54 }
55 return instance;
56 }
57
WifiP2pServiceImpl()58 WifiP2pServiceImpl::WifiP2pServiceImpl()
59 : SystemAbility(WIFI_P2P_ABILITY_ID, true), mPublishFlag(false), mState(ServiceRunningState::STATE_NOT_START)
60 {}
61
~WifiP2pServiceImpl()62 WifiP2pServiceImpl::~WifiP2pServiceImpl()
63 {}
64
OnStart()65 void WifiP2pServiceImpl::OnStart()
66 {
67 WIFI_LOGI("Start p2p service!");
68 if (mState == ServiceRunningState::STATE_RUNNING) {
69 WIFI_LOGI("P2p service has already started.");
70 return;
71 }
72 if (WifiManager::GetInstance().Init() < 0) {
73 WIFI_LOGE("WifiManager init failed!");
74 return;
75 }
76 if (!Init()) {
77 WIFI_LOGE("Failed to init p2p service");
78 OnStop();
79 return;
80 }
81 mState = ServiceRunningState::STATE_RUNNING;
82 WifiManager::GetInstance().AddSupportedFeatures(WifiFeatures::WIFI_FEATURE_P2P);
83 WifiOprMidState p2pState = WifiConfigCenter::GetInstance().GetP2pMidState();
84 auto &pWifiP2pManager = WifiManager::GetInstance().GetWifiP2pManager();
85 if (p2pState == WifiOprMidState::CLOSED && pWifiP2pManager) {
86 pWifiP2pManager->StartUnloadP2PSaTimer();
87 }
88 }
89
OnStop()90 void WifiP2pServiceImpl::OnStop()
91 {
92 mState = ServiceRunningState::STATE_NOT_START;
93 mPublishFlag = false;
94 WIFI_LOGI("Stop p2p service!");
95 }
96
Init()97 bool WifiP2pServiceImpl::Init()
98 {
99 if (!mPublishFlag) {
100 bool ret = Publish(WifiP2pServiceImpl::GetInstance());
101 if (!ret) {
102 WIFI_LOGE("Failed to publish p2p service!");
103 return false;
104 }
105 mPublishFlag = true;
106 }
107 return true;
108 }
109
CheckCanEnableP2p(void)110 ErrCode WifiP2pServiceImpl::CheckCanEnableP2p(void)
111 {
112 if (WifiPermissionUtils::VerifySameProcessPermission() == PERMISSION_DENIED) {
113 WIFI_LOGE("EnableP2p:VerifySameProcessPermission PERMISSION_DENIED!");
114 return WIFI_OPT_PERMISSION_DENIED;
115 }
116 /**
117 * when airplane mode opened, if the config "can_open_sta_when_airplanemode"
118 * opened, then can open sta; other, return forbid.
119 */
120 if (WifiConfigCenter::GetInstance().GetAirplaneModeState() == MODE_STATE_OPEN &&
121 !WifiSettings::GetInstance().GetCanOpenStaWhenAirplaneMode()) {
122 WIFI_LOGI("current airplane mode and can not use p2p, open failed!");
123 return WIFI_OPT_FORBID_AIRPLANE;
124 }
125 if (WifiConfigCenter::GetInstance().GetPowerSavingModeState() == 1) {
126 WIFI_LOGW("current power saving mode and can not use p2p, open failed!");
127 return WIFI_OPT_FORBID_POWSAVING;
128 }
129 return WIFI_OPT_SUCCESS;
130 }
131
EnableP2p(void)132 ErrCode WifiP2pServiceImpl::EnableP2p(void)
133 {
134 WIFI_LOGI("EnableP2p");
135 ErrCode errCode = CheckCanEnableP2p();
136 if (errCode != WIFI_OPT_SUCCESS) {
137 return errCode;
138 }
139
140 WifiOprMidState curState = WifiConfigCenter::GetInstance().GetP2pMidState();
141 if (curState != WifiOprMidState::CLOSED) {
142 WIFI_LOGW("current p2p state is %{public}d", static_cast<int>(curState));
143 if (curState == WifiOprMidState::CLOSING) {
144 return WIFI_OPT_OPEN_FAIL_WHEN_CLOSING;
145 } else {
146 return WIFI_OPT_OPEN_SUCC_WHEN_OPENED;
147 }
148 }
149 if (!WifiConfigCenter::GetInstance().SetP2pMidState(curState, WifiOprMidState::OPENING)) {
150 WIFI_LOGD("set p2p mid state opening failed!");
151 return WIFI_OPT_OPEN_SUCC_WHEN_OPENED;
152 }
153 ErrCode ret = WIFI_OPT_FAILED;
154 do {
155 if (WifiServiceManager::GetInstance().CheckAndEnforceService(WIFI_SERVICE_P2P) < 0) {
156 WIFI_LOGE("Load %{public}s service failed!", WIFI_SERVICE_P2P);
157 break;
158 }
159 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
160 if (pService == nullptr) {
161 WIFI_LOGE("Create %{public}s service failed!", WIFI_SERVICE_P2P);
162 break;
163 }
164 ret = pService->RegisterP2pServiceCallbacks(WifiManager::GetInstance().GetWifiP2pManager()->GetP2pCallback());
165 if (ret != WIFI_OPT_SUCCESS) {
166 WIFI_LOGE("Register p2p service callback failed!");
167 break;
168 }
169 ret = pService->EnableP2p();
170 if (ret != WIFI_OPT_SUCCESS) {
171 WIFI_LOGE("service EnableP2p failed, ret %{public}d!", static_cast<int>(ret));
172 break;
173 }
174 } while (false);
175 if (ret != WIFI_OPT_SUCCESS) {
176 WifiConfigCenter::GetInstance().SetP2pMidState(WifiOprMidState::OPENING, WifiOprMidState::CLOSED);
177 WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_P2P);
178 } else {
179 WifiManager::GetInstance().GetWifiP2pManager()->StopUnloadP2PSaTimer();
180 }
181 return ret;
182 }
183
DisableP2p(void)184 ErrCode WifiP2pServiceImpl::DisableP2p(void)
185 {
186 WIFI_LOGI("DisableP2p");
187 if (WifiPermissionUtils::VerifySameProcessPermission() == PERMISSION_DENIED) {
188 WIFI_LOGE("DisableP2p:VerifySameProcessPermission PERMISSION_DENIED!");
189 return WIFI_OPT_PERMISSION_DENIED;
190 }
191
192 WifiOprMidState curState = WifiConfigCenter::GetInstance().GetP2pMidState();
193 if (curState != WifiOprMidState::RUNNING) {
194 WIFI_LOGI("current p2p state is %{public}d", static_cast<int>(curState));
195 if (curState == WifiOprMidState::OPENING) {
196 return WIFI_OPT_CLOSE_FAIL_WHEN_OPENING;
197 } else {
198 return WIFI_OPT_CLOSE_SUCC_WHEN_CLOSED;
199 }
200 }
201 if (!IsP2pServiceRunning()) {
202 WIFI_LOGE("P2pService is not running!");
203 return WIFI_OPT_P2P_NOT_OPENED;
204 }
205 if (!WifiConfigCenter::GetInstance().SetP2pMidState(curState, WifiOprMidState::CLOSING)) {
206 WIFI_LOGD("set p2p mid state opening failed! may be other activity has been operated");
207 return WIFI_OPT_CLOSE_SUCC_WHEN_CLOSED;
208 }
209 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
210 if (pService == nullptr) {
211 WifiConfigCenter::GetInstance().SetP2pMidState(WifiOprMidState::CLOSED);
212 WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_P2P);
213 return WIFI_OPT_SUCCESS;
214 }
215 ErrCode ret = pService->DisableP2p();
216 if (ret != WIFI_OPT_SUCCESS) {
217 WifiConfigCenter::GetInstance().SetP2pMidState(WifiOprMidState::CLOSING, WifiOprMidState::RUNNING);
218 }
219 return ret;
220 }
221
DiscoverDevices(void)222 ErrCode WifiP2pServiceImpl::DiscoverDevices(void)
223 {
224 WIFI_LOGI("DiscoverDevices");
225 int apiVersion = WifiPermissionUtils::GetApiVersion();
226 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
227 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
228 return WIFI_OPT_PERMISSION_DENIED;
229 }
230 if (apiVersion == API_VERSION_9) {
231 #ifndef SUPPORT_RANDOM_MAC_ADDR
232 if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
233 WIFI_LOGE("DiscoverDevices:VerifyGetScanInfosPermission PERMISSION_DENIED!");
234 return WIFI_OPT_PERMISSION_DENIED;
235 }
236 #endif
237 }
238 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
239 WIFI_LOGE("DiscoverDevices:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
240 return WIFI_OPT_PERMISSION_DENIED;
241 }
242
243 if (!IsP2pServiceRunning()) {
244 WIFI_LOGE("P2pService is not running!");
245 return WIFI_OPT_P2P_NOT_OPENED;
246 }
247
248 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
249 if (pService == nullptr) {
250 WIFI_LOGE("Get P2P service failed!");
251 return WIFI_OPT_P2P_NOT_OPENED;
252 }
253 return pService->DiscoverDevices();
254 }
255
StopDiscoverDevices(void)256 ErrCode WifiP2pServiceImpl::StopDiscoverDevices(void)
257 {
258 WIFI_LOGI("StopDiscoverDevices");
259 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
260 WIFI_LOGE("StopDiscoverDevices:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
261 return WIFI_OPT_PERMISSION_DENIED;
262 }
263
264 if (!IsP2pServiceRunning()) {
265 WIFI_LOGE("P2pService is not running!");
266 return WIFI_OPT_P2P_NOT_OPENED;
267 }
268
269 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
270 if (pService == nullptr) {
271 WIFI_LOGE("Get P2P service failed!");
272 return WIFI_OPT_P2P_NOT_OPENED;
273 }
274 return pService->StopDiscoverDevices();
275 }
276
DiscoverServices(void)277 ErrCode WifiP2pServiceImpl::DiscoverServices(void)
278 {
279 WIFI_LOGI("DiscoverServices");
280 if (WifiPermissionUtils::VerifyGetWifiDirectDevicePermission() == PERMISSION_DENIED) {
281 WIFI_LOGE("DiscoverServices:VerifyGetWifiDirectDevicePermission PERMISSION_DENIED!");
282 return WIFI_OPT_PERMISSION_DENIED;
283 }
284
285 if (!IsP2pServiceRunning()) {
286 WIFI_LOGE("P2pService is not running!");
287 return WIFI_OPT_P2P_NOT_OPENED;
288 }
289
290 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
291 if (pService == nullptr) {
292 WIFI_LOGE("Get P2P service failed!");
293 return WIFI_OPT_P2P_NOT_OPENED;
294 }
295 return pService->DiscoverServices();
296 }
297
StopDiscoverServices(void)298 ErrCode WifiP2pServiceImpl::StopDiscoverServices(void)
299 {
300 WIFI_LOGI("StopDiscoverServices");
301 if (!WifiAuthCenter::IsNativeProcess()) {
302 WIFI_LOGE("StopDiscoverServices:NOT NATIVE PROCESS, PERMISSION_DENIED!");
303 return WIFI_OPT_PERMISSION_DENIED;
304 }
305 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
306 WIFI_LOGE("StopDiscoverServices:VerifySetWifiInfoPermission PERMISSION_DENIED!");
307 return WIFI_OPT_PERMISSION_DENIED;
308 }
309 if (!IsP2pServiceRunning()) {
310 WIFI_LOGE("P2pService is not running!");
311 return WIFI_OPT_P2P_NOT_OPENED;
312 }
313
314 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
315 if (pService == nullptr) {
316 WIFI_LOGE("Get P2P service failed!");
317 return WIFI_OPT_P2P_NOT_OPENED;
318 }
319 return pService->StopDiscoverServices();
320 }
321
RequestService(const WifiP2pDevice & device,const WifiP2pServiceRequest & request)322 ErrCode WifiP2pServiceImpl::RequestService(const WifiP2pDevice &device, const WifiP2pServiceRequest &request)
323 {
324 WIFI_LOGI("RequestService");
325 if (WifiPermissionUtils::VerifyGetWifiDirectDevicePermission() == PERMISSION_DENIED) {
326 WIFI_LOGE("RequestService:VerifyGetWifiDirectDevicePermission PERMISSION_DENIED!");
327 return WIFI_OPT_PERMISSION_DENIED;
328 }
329
330 if (!IsP2pServiceRunning()) {
331 WIFI_LOGE("P2pService is not running!");
332 return WIFI_OPT_P2P_NOT_OPENED;
333 }
334
335 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
336 if (pService == nullptr) {
337 WIFI_LOGE("Get P2P service failed!");
338 return WIFI_OPT_P2P_NOT_OPENED;
339 }
340 return pService->RequestService(device, request);
341 }
342
PutLocalP2pService(const WifiP2pServiceInfo & srvInfo)343 ErrCode WifiP2pServiceImpl::PutLocalP2pService(const WifiP2pServiceInfo &srvInfo)
344 {
345 WIFI_LOGI("PutLocalP2pService, service name is [%{public}s]", srvInfo.GetServiceName().c_str());
346 if (WifiPermissionUtils::VerifyGetWifiInfoInternalPermission() == PERMISSION_DENIED) {
347 WIFI_LOGE("PutLocalP2pService:VerifyGetWifiInfoInternalPermission PERMISSION_DENIED!");
348 return WIFI_OPT_PERMISSION_DENIED;
349 }
350 if (!IsP2pServiceRunning()) {
351 WIFI_LOGE("P2pService is not running!");
352 return WIFI_OPT_P2P_NOT_OPENED;
353 }
354
355 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
356 if (pService == nullptr) {
357 WIFI_LOGE("Get P2P service failed!");
358 return WIFI_OPT_P2P_NOT_OPENED;
359 }
360 return pService->PutLocalP2pService(srvInfo);
361 }
362
DeleteLocalP2pService(const WifiP2pServiceInfo & srvInfo)363 ErrCode WifiP2pServiceImpl::DeleteLocalP2pService(const WifiP2pServiceInfo &srvInfo)
364 {
365 WIFI_LOGI("DeleteLocalP2pService, service name is [%{public}s]", srvInfo.GetServiceName().c_str());
366 if (WifiPermissionUtils::VerifyGetWifiInfoInternalPermission() == PERMISSION_DENIED) {
367 WIFI_LOGE("DeleteLocalP2pService:VerifyGetWifiInfoInternalPermission PERMISSION_DENIED!");
368 return WIFI_OPT_PERMISSION_DENIED;
369 }
370 if (!IsP2pServiceRunning()) {
371 WIFI_LOGE("P2pService is not running!");
372 return WIFI_OPT_P2P_NOT_OPENED;
373 }
374
375 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
376 if (pService == nullptr) {
377 WIFI_LOGE("Get P2P service failed!");
378 return WIFI_OPT_P2P_NOT_OPENED;
379 }
380 return pService->DeleteLocalP2pService(srvInfo);
381 }
382
StartP2pListen(int period,int interval)383 ErrCode WifiP2pServiceImpl::StartP2pListen(int period, int interval)
384 {
385 WIFI_LOGI("StartP2pListen, period %{public}d, interval %{public}d", period, interval);
386 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
387 WIFI_LOGE("StartP2pListen:VerifyWifiConnectionPermission PERMISSION_DENIED!");
388 return WIFI_OPT_PERMISSION_DENIED;
389 }
390
391 if (!IsP2pServiceRunning()) {
392 WIFI_LOGE("P2pService is not running!");
393 return WIFI_OPT_P2P_NOT_OPENED;
394 }
395
396 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
397 if (pService == nullptr) {
398 WIFI_LOGE("Get P2P service failed!");
399 return WIFI_OPT_P2P_NOT_OPENED;
400 }
401 return pService->StartP2pListen(period, interval);
402 }
403
StopP2pListen()404 ErrCode WifiP2pServiceImpl::StopP2pListen()
405 {
406 WIFI_LOGI("StopP2pListen");
407 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
408 WIFI_LOGE("StopP2pListen:VerifyWifiConnectionPermission PERMISSION_DENIED!");
409 return WIFI_OPT_PERMISSION_DENIED;
410 }
411
412 if (!IsP2pServiceRunning()) {
413 WIFI_LOGE("P2pService is not running!");
414 return WIFI_OPT_P2P_NOT_OPENED;
415 }
416
417 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
418 if (pService == nullptr) {
419 WIFI_LOGE("Get P2P service failed!");
420 return WIFI_OPT_P2P_NOT_OPENED;
421 }
422 return pService->StopP2pListen();
423 }
424
CreateGroup(const WifiP2pConfig & config)425 ErrCode WifiP2pServiceImpl::CreateGroup(const WifiP2pConfig &config)
426 {
427 int callingUid = GetCallingUid();
428 WIFI_LOGI("Uid %{public}d createGroup, network name is [%{public}s]", callingUid, config.GetGroupName().c_str());
429 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
430 WIFI_LOGE("CreateGroup:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
431 return WIFI_OPT_PERMISSION_DENIED;
432 }
433 uint32_t passLen = config.GetPassphrase().length();
434 if ((!config.GetPassphrase().empty()) &&
435 (passLen < WIFI_P2P_PASSPHRASE_MIN_LEN || passLen > WIFI_P2P_PASSPHRASE_MAX_LEN)) {
436 WIFI_LOGE("CreateGroup:VerifyPassphrase length failed!");
437 return WIFI_OPT_INVALID_PARAM;
438 }
439 if (CheckMacIsValid(config.GetDeviceAddress()) != 0) {
440 WIFI_LOGE("CreateGroup:VerifyDeviceAddress failed!");
441 return WIFI_OPT_INVALID_PARAM;
442 }
443
444 if (!IsP2pServiceRunning()) {
445 WIFI_LOGE("P2pService is not running!");
446 return WIFI_OPT_P2P_NOT_OPENED;
447 }
448
449 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
450 if (pService == nullptr) {
451 WIFI_LOGE("Get P2P service failed!");
452 return WIFI_OPT_P2P_NOT_OPENED;
453 }
454 return pService->CreateGroup(config);
455 }
456
RemoveGroup()457 ErrCode WifiP2pServiceImpl::RemoveGroup()
458 {
459 WIFI_LOGI("RemoveGroup");
460 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
461 WIFI_LOGE("RemoveGroup:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
462 return WIFI_OPT_PERMISSION_DENIED;
463 }
464
465 if (!IsP2pServiceRunning()) {
466 WIFI_LOGE("P2pService is not running!");
467 return WIFI_OPT_P2P_NOT_OPENED;
468 }
469
470 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
471 if (pService == nullptr) {
472 WIFI_LOGE("Get P2P service failed!");
473 return WIFI_OPT_P2P_NOT_OPENED;
474 }
475 WifiP2pGroupInfo config;
476 ErrCode ret = pService->GetCurrentGroup(config);
477 if (ret != WIFI_OPT_SUCCESS) {
478 WIFI_LOGE("RemoveGroup:GetCurrentGroup failed!");
479 pService->RemoveGroup();
480 return WIFI_OPT_FAILED;
481 }
482 return pService->RemoveGroup();
483 }
484
RemoveGroupClient(const GcInfo & info)485 ErrCode WifiP2pServiceImpl::RemoveGroupClient(const GcInfo &info)
486 {
487 WIFI_LOGI("RemoveGroupClient");
488 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
489 WIFI_LOGE("RemoveGroupClient:VerifySetWifiInfoPermission PERMISSION_DENIED!");
490 return WIFI_OPT_PERMISSION_DENIED;
491 }
492
493 if (!IsP2pServiceRunning()) {
494 WIFI_LOGE("P2pService is not running!");
495 return WIFI_OPT_P2P_NOT_OPENED;
496 }
497
498 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
499 if (pService == nullptr) {
500 WIFI_LOGE("Get P2P service failed!");
501 return WIFI_OPT_P2P_NOT_OPENED;
502 }
503 return pService->RemoveGroupClient(info);
504 }
505
DeleteGroup(const WifiP2pGroupInfo & group)506 ErrCode WifiP2pServiceImpl::DeleteGroup(const WifiP2pGroupInfo &group)
507 {
508 WIFI_LOGI("DeleteGroup, group name [%{public}s]", group.GetGroupName().c_str());
509 if (!WifiAuthCenter::IsSystemAccess()) {
510 WIFI_LOGE("DeleteGroup:NOT System APP, PERMISSION_DENIED!");
511 return WIFI_OPT_NON_SYSTEMAPP;
512 }
513 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
514 WIFI_LOGE("DeleteGroup:VerifySetWifiInfoPermission PERMISSION_DENIED!");
515 return WIFI_OPT_PERMISSION_DENIED;
516 }
517
518 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
519 WIFI_LOGE("DeleteGroup:VerifyWifiConnectionPermission PERMISSION_DENIED!");
520 return WIFI_OPT_PERMISSION_DENIED;
521 }
522
523 if (!IsP2pServiceRunning()) {
524 WIFI_LOGE("P2pService is not running!");
525 return WIFI_OPT_P2P_NOT_OPENED;
526 }
527
528 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
529 if (pService == nullptr) {
530 WIFI_LOGE("Get P2P service failed!");
531 return WIFI_OPT_P2P_NOT_OPENED;
532 }
533 return pService->DeleteGroup(group);
534 }
535
P2pConnect(const WifiP2pConfig & config)536 ErrCode WifiP2pServiceImpl::P2pConnect(const WifiP2pConfig &config)
537 {
538 WIFI_LOGI("P2pConnect device address [%{private}s], addressType: %{public}d], "
539 "pid:%{public}d, uid:%{public}d ,BundleName:%{public}s",
540 config.GetDeviceAddress().c_str(), config.GetDeviceAddressType(),
541 GetCallingPid(), GetCallingUid(), GetBundleName().c_str());
542 int apiVersion = WifiPermissionUtils::GetApiVersion();
543 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
544 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
545 return WIFI_OPT_PERMISSION_DENIED;
546 }
547 if (apiVersion == API_VERSION_9) {
548 #ifndef SUPPORT_RANDOM_MAC_ADDR
549 if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
550 WIFI_LOGE("P2pConnect:VerifyGetScanInfosPermission PERMISSION_DENIED!");
551 return WIFI_OPT_PERMISSION_DENIED;
552 }
553 #endif
554 }
555 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
556 WIFI_LOGE("P2pConnect:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
557 return WIFI_OPT_PERMISSION_DENIED;
558 }
559
560 if (CheckMacIsValid(config.GetDeviceAddress()) != 0) {
561 WIFI_LOGE("P2pConnect:VerifyDeviceAddress failed!");
562 return WIFI_OPT_INVALID_PARAM;
563 }
564
565 uint32_t passLen = config.GetPassphrase().length();
566 if (passLen != 0 && (passLen < WIFI_P2P_PASSPHRASE_MIN_LEN || passLen > WIFI_P2P_PASSPHRASE_MAX_LEN)) {
567 WIFI_LOGE("P2pConnect:VerifyPassphrase failed!");
568 return WIFI_OPT_INVALID_PARAM;
569 }
570
571 if (!IsP2pServiceRunning()) {
572 WIFI_LOGE("P2pService is not running!");
573 return WIFI_OPT_P2P_NOT_OPENED;
574 }
575 WifiP2pConfig updateConfig = config;
576 #ifdef SUPPORT_RANDOM_MAC_ADDR
577 if (MacAddress::IsValidMac(config.GetDeviceAddress())) {
578 if (config.GetDeviceAddressType() > REAL_DEVICE_ADDRESS) {
579 WIFI_LOGE("%{public}s: invalid bssidType:%{public}d",
580 __func__, config.GetDeviceAddressType());
581 return WIFI_OPT_INVALID_PARAM;
582 }
583 WifiMacAddrInfo macAddrInfo;
584 macAddrInfo.bssid = config.GetDeviceAddress();
585 macAddrInfo.bssidType = config.GetDeviceAddressType();
586 std::string randomMacAddr =
587 WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::P2P_DEVICE_MACADDR_INFO, macAddrInfo);
588 if (randomMacAddr.empty()) {
589 WIFI_LOGW("no record found, bssid:%{private}s, bssidType:%{public}d",
590 macAddrInfo.bssid.c_str(), macAddrInfo.bssidType);
591 } else {
592 WIFI_LOGI("%{public}s: find the record, bssid:%{private}s, bssidType:%{public}d, randomMac:%{private}s",
593 __func__, config.GetDeviceAddress().c_str(), config.GetDeviceAddressType(), randomMacAddr.c_str());
594 /* random MAC address are translated into real MAC address */
595 if (config.GetDeviceAddressType() == RANDOM_DEVICE_ADDRESS) {
596 updateConfig.SetDeviceAddress(randomMacAddr);
597 updateConfig.SetDeviceAddressType(REAL_DEVICE_ADDRESS);
598 WIFI_LOGI("%{public}s: the record is updated, bssid:%{private}s, bssidType:%{public}d",
599 __func__, updateConfig.GetDeviceAddress().c_str(), updateConfig.GetDeviceAddressType());
600 }
601 }
602 } else {
603 WIFI_LOGW("invalid mac address");
604 }
605 #endif
606
607 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
608 if (pService == nullptr) {
609 WIFI_LOGE("Get P2P service failed!");
610 return WIFI_OPT_P2P_NOT_OPENED;
611 }
612 WriteP2pKpiCountHiSysEvent(static_cast<int>(P2P_CHR_EVENT::CONN_CNT));
613 return pService->P2pConnect(updateConfig);
614 }
615
P2pCancelConnect()616 ErrCode WifiP2pServiceImpl::P2pCancelConnect()
617 {
618 WIFI_LOGI("P2pCancelConnect");
619 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
620 WIFI_LOGE("P2pCancelConnect:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
621 return WIFI_OPT_PERMISSION_DENIED;
622 }
623
624 if (!IsP2pServiceRunning()) {
625 WIFI_LOGE("P2pService is not running!");
626 return WIFI_OPT_P2P_NOT_OPENED;
627 }
628
629 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
630 if (pService == nullptr) {
631 WIFI_LOGE("Get P2P service failed!");
632 return WIFI_OPT_P2P_NOT_OPENED;
633 }
634 return pService->P2pCancelConnect();
635 }
636
QueryP2pLinkedInfo(WifiP2pLinkedInfo & linkedInfo)637 ErrCode WifiP2pServiceImpl::QueryP2pLinkedInfo(WifiP2pLinkedInfo &linkedInfo)
638 {
639 WIFI_LOGI("QueryP2pLinkedInfo group owner address:%{private}s, pid: %{public}d, uid: %{public}d",
640 linkedInfo.GetGroupOwnerAddress().c_str(), GetCallingPid(), GetCallingUid());
641 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
642 WIFI_LOGE("QueryP2pLinkedInfo:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
643 return WIFI_OPT_PERMISSION_DENIED;
644 }
645
646 if (!IsP2pServiceRunning()) {
647 WIFI_LOGE("P2pService is not running!");
648 return WIFI_OPT_P2P_NOT_OPENED;
649 }
650
651 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
652 if (pService == nullptr) {
653 WIFI_LOGE("Get P2P service failed!");
654 return WIFI_OPT_P2P_NOT_OPENED;
655 }
656
657 ErrCode ret = pService->QueryP2pLinkedInfo(linkedInfo);
658 if (ret == WIFI_OPT_SUCCESS) {
659 if (WifiPermissionUtils::VerifyGetWifiLocalMacPermission() == PERMISSION_DENIED) {
660 WIFI_LOGE("QueryP2pLinkedInfo:VerifyGetWifiLocalMacPermission PERMISSION_DENIED!");
661 linkedInfo.SetIsGroupOwnerAddress("00.00.00.00");
662 }
663 }
664
665 return ret;
666 }
667
GetCurrentGroup(WifiP2pGroupInfo & group)668 ErrCode WifiP2pServiceImpl::GetCurrentGroup(WifiP2pGroupInfo &group)
669 {
670 WIFI_LOGD("GetCurrentGroup pid: %{public}d, uid: %{public}d", GetCallingPid(), GetCallingUid());
671 int apiVersion = WifiPermissionUtils::GetApiVersion();
672 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
673 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
674 return WIFI_OPT_PERMISSION_DENIED;
675 }
676 if (apiVersion == API_VERSION_9) {
677 #ifndef SUPPORT_RANDOM_MAC_ADDR
678 if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
679 WIFI_LOGE("GetCurrentGroup:VerifyGetScanInfosPermission PERMISSION_DENIED!");
680 return WIFI_OPT_PERMISSION_DENIED;
681 }
682 #endif
683 }
684 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
685 WIFI_LOGE("GetCurrentGroup:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
686 return WIFI_OPT_PERMISSION_DENIED;
687 }
688
689 if (!IsP2pServiceRunning()) {
690 WIFI_LOGE("P2pService is not running!");
691 return WIFI_OPT_P2P_NOT_OPENED;
692 }
693
694 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
695 if (pService == nullptr) {
696 WIFI_LOGE("Get P2P service failed!");
697 return WIFI_OPT_P2P_NOT_OPENED;
698 }
699 ErrCode errCode = pService->GetCurrentGroup(group);
700 #ifdef SUPPORT_RANDOM_MAC_ADDR
701 if (WifiPermissionUtils::VerifyGetWifiPeersMacPermission() == PERMISSION_DENIED) {
702 WIFI_LOGI("%{public}s: GET_WIFI_PEERS_MAC PERMISSION_DENIED", __func__);
703 WifiMacAddrInfo ownMacAddrInfo;
704 WifiP2pDevice owner = group.GetOwner();
705 ownMacAddrInfo.bssid = owner.GetDeviceAddress();
706 ownMacAddrInfo.bssidType = owner.GetDeviceAddressType();
707 std::string ownRandomMacAddr =
708 WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO,
709 ownMacAddrInfo);
710 if (!ownRandomMacAddr.empty() && (ownMacAddrInfo.bssidType == REAL_DEVICE_ADDRESS)) {
711 owner.SetDeviceAddress(ownRandomMacAddr);
712 owner.SetDeviceAddressType(RANDOM_DEVICE_ADDRESS);
713 group.SetOwner(owner);
714
715 std::vector<WifiP2pDevice> vecClientDevice = group.GetClientDevices();
716 for (auto iter = vecClientDevice.begin(); iter != vecClientDevice.end(); ++iter) {
717 WifiMacAddrInfo clientMacAddrInfo;
718 clientMacAddrInfo.bssid = iter->GetDeviceAddress();
719 clientMacAddrInfo.bssidType = iter->GetDeviceAddressType();
720 std::string clientRandomMacAddr =
721 WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::P2P_CURRENT_GROUP_MACADDR_INFO,
722 clientMacAddrInfo);
723 if (!clientRandomMacAddr.empty() &&
724 (clientMacAddrInfo.bssidType == REAL_DEVICE_ADDRESS)) {
725 iter->SetDeviceAddress(clientRandomMacAddr);
726 iter->SetDeviceAddressType(RANDOM_DEVICE_ADDRESS);
727 WIFI_LOGI("%{public}s: the record is updated, bssid:%{private}s, bssidType:%{public}d",
728 __func__, iter->GetDeviceAddress().c_str(), iter->GetDeviceAddressType());
729 }
730 }
731 group.SetClientDevices(vecClientDevice);
732 }
733 }
734 #endif
735 return errCode;
736 }
737
GetP2pEnableStatus(int & status)738 ErrCode WifiP2pServiceImpl::GetP2pEnableStatus(int &status)
739 {
740 WIFI_LOGI("GetP2pEnableStatus");
741 if (!WifiAuthCenter::IsNativeProcess()) {
742 WIFI_LOGE("GetP2pEnableStatus:NOT NATIVE PROCESS, PERMISSION_DENIED!");
743 return WIFI_OPT_PERMISSION_DENIED;
744 }
745 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
746 WIFI_LOGE("GetP2pEnableStatus:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
747 return WIFI_OPT_PERMISSION_DENIED;
748 }
749 status = WifiConfigCenter::GetInstance().GetP2pState();
750 return WIFI_OPT_SUCCESS;
751 }
752
GetP2pDiscoverStatus(int & status)753 ErrCode WifiP2pServiceImpl::GetP2pDiscoverStatus(int &status)
754 {
755 WIFI_LOGI("GetP2pDiscoverStatus");
756 if (WifiPermissionUtils::VerifyGetWifiInfoInternalPermission() == PERMISSION_DENIED) {
757 WIFI_LOGE("GetP2pDiscoverStatus:VerifyGetWifiInfoInternalPermission PERMISSION_DENIED!");
758 return WIFI_OPT_PERMISSION_DENIED;
759 }
760 if (!IsP2pServiceRunning()) {
761 WIFI_LOGE("P2pService is not running!");
762 return WIFI_OPT_P2P_NOT_OPENED;
763 }
764
765 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
766 if (pService == nullptr) {
767 WIFI_LOGE("Get P2P service failed!");
768 return WIFI_OPT_P2P_NOT_OPENED;
769 }
770 return pService->GetP2pDiscoverStatus(status);
771 }
772
GetP2pConnectedStatus(int & status)773 ErrCode WifiP2pServiceImpl::GetP2pConnectedStatus(int &status)
774 {
775 WIFI_LOGI("GetP2pConnectedStatus");
776 if (!WifiAuthCenter::IsNativeProcess()) {
777 WIFI_LOGE("GetP2pConnectedStatus:NOT NATIVE PROCESS, PERMISSION_DENIED!");
778 return WIFI_OPT_PERMISSION_DENIED;
779 }
780 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
781 WIFI_LOGE("GetP2pConnectedStatus:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
782 return WIFI_OPT_PERMISSION_DENIED;
783 }
784 if (!IsP2pServiceRunning()) {
785 WIFI_LOGE("P2pService is not running!");
786 return WIFI_OPT_P2P_NOT_OPENED;
787 }
788
789 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
790 if (pService == nullptr) {
791 WIFI_LOGE("Get P2P service failed!");
792 return WIFI_OPT_P2P_NOT_OPENED;
793 }
794 return pService->GetP2pConnectedStatus(status);
795 }
796
QueryP2pDevices(std::vector<WifiP2pDevice> & devices)797 ErrCode WifiP2pServiceImpl::QueryP2pDevices(std::vector<WifiP2pDevice> &devices)
798 {
799 WIFI_LOGI("QueryP2pDevices");
800 int apiVersion = WifiPermissionUtils::GetApiVersion();
801 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
802 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
803 return WIFI_OPT_PERMISSION_DENIED;
804 }
805 if (apiVersion == API_VERSION_9) {
806 #ifndef SUPPORT_RANDOM_MAC_ADDR
807 if (WifiPermissionUtils::VerifyGetScanInfosPermission() == PERMISSION_DENIED) {
808 WIFI_LOGE("QueryP2pDevices:VerifyGetScanInfosPermission PERMISSION_DENIED!");
809 return WIFI_OPT_PERMISSION_DENIED;
810 }
811 #endif
812 }
813 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
814 WIFI_LOGE("QueryP2pDevices:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
815 return WIFI_OPT_PERMISSION_DENIED;
816 }
817
818 if (!IsP2pServiceRunning()) {
819 WIFI_LOGE("P2pService is not running!");
820 return WIFI_OPT_P2P_NOT_OPENED;
821 }
822
823 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
824 if (pService == nullptr) {
825 WIFI_LOGE("Get P2P service failed!");
826 return WIFI_OPT_P2P_NOT_OPENED;
827 }
828 ErrCode errCode = pService->QueryP2pDevices(devices);
829 #ifdef SUPPORT_RANDOM_MAC_ADDR
830 if (WifiPermissionUtils::VerifyGetWifiPeersMacPermission() == PERMISSION_DENIED) {
831 WIFI_LOGI("%{public}s: GET_WIFI_PEERS_MAC PERMISSION_DENIED, size: %{public}zu",
832 __func__, devices.size());
833 for (auto iter = devices.begin(); iter != devices.end(); ++iter) {
834 WifiMacAddrInfo macAddrInfo;
835 macAddrInfo.bssid = iter->GetDeviceAddress();
836 macAddrInfo.bssidType = iter->GetDeviceAddressType();
837 std::string randomMacAddr =
838 WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::P2P_DEVICE_MACADDR_INFO,
839 macAddrInfo);
840 if (!randomMacAddr.empty() &&
841 (macAddrInfo.bssidType == REAL_DEVICE_ADDRESS)) {
842 iter->SetDeviceAddress(randomMacAddr);
843 iter->SetDeviceAddressType(RANDOM_DEVICE_ADDRESS);
844 WIFI_LOGI("%{public}s: the record is updated, bssid:%{private}s, bssidType:%{public}d",
845 __func__, iter->GetDeviceAddress().c_str(), iter->GetDeviceAddressType());
846 }
847 }
848 }
849 #endif
850 return errCode;
851 }
852
QueryP2pLocalDevice(WifiP2pDevice & device)853 ErrCode WifiP2pServiceImpl::QueryP2pLocalDevice(WifiP2pDevice &device)
854 {
855 WIFI_LOGI("QueryP2pLocalDevice");
856
857 int apiVersion = WifiPermissionUtils::GetApiVersion();
858 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
859 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
860 return WIFI_OPT_PERMISSION_DENIED;
861 }
862 if (apiVersion >= API_VERSION_9 && apiVersion < API_VERSION_11) {
863 if (WifiPermissionUtils::VerifyGetWifiConfigPermission() == PERMISSION_DENIED) {
864 WIFI_LOGE("QueryP2pLocalDevice:VerifyGetWifiConfigPermission PERMISSION_DENIED!");
865 return WIFI_OPT_PERMISSION_DENIED;
866 }
867 }
868 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
869 WIFI_LOGE("QueryP2pLocalDevice:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
870 return WIFI_OPT_PERMISSION_DENIED;
871 }
872
873 if (!IsP2pServiceRunning()) {
874 WIFI_LOGE("P2pService is not runing!");
875 return WIFI_OPT_P2P_NOT_OPENED;
876 }
877
878 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
879 if (pService == nullptr) {
880 WIFI_LOGE("Get P2P service failed!");
881 return WIFI_OPT_P2P_NOT_OPENED;
882 }
883
884 ErrCode ret = pService->QueryP2pLocalDevice(device);
885 if (WifiPermissionUtils::VerifyGetWifiLocalMacPermission() == PERMISSION_DENIED) {
886 WIFI_LOGE("QueryP2pLocalDevice:VerifyGetWifiLocalMacPermission PERMISSION_DENIED!");
887 device.SetDeviceAddress("00:00:00:00:00:00");
888 }
889 return ret;
890 }
891
QueryP2pGroups(std::vector<WifiP2pGroupInfo> & groups)892 ErrCode WifiP2pServiceImpl::QueryP2pGroups(std::vector<WifiP2pGroupInfo> &groups)
893 {
894 WIFI_LOGI("QueryP2pGroups");
895 int apiVersion = WifiPermissionUtils::GetApiVersion();
896 if (apiVersion < API_VERSION_9 && apiVersion != API_VERSION_INVALID) {
897 WIFI_LOGE("%{public}s The version %{public}d is too early to be supported", __func__, apiVersion);
898 return WIFI_OPT_PERMISSION_DENIED;
899 }
900 if (!WifiAuthCenter::IsSystemAccess()) {
901 WIFI_LOGE("QueryP2pGroups:NOT System APP, PERMISSION_DENIED!");
902 return WIFI_OPT_NON_SYSTEMAPP;
903 }
904 if (apiVersion == API_VERSION_9) {
905 #ifndef SUPPORT_RANDOM_MAC_ADDR
906 if (WifiPermissionUtils::VerifyGetWifiDirectDevicePermission() == PERMISSION_DENIED) {
907 WIFI_LOGE("QueryP2pGroups:VerifyGetWifiDirectDevicePermission PERMISSION_DENIED!");
908 return WIFI_OPT_PERMISSION_DENIED;
909 }
910 #endif
911 }
912 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
913 WIFI_LOGE("QueryP2pGroups:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
914 return WIFI_OPT_PERMISSION_DENIED;
915 }
916
917 if (!IsP2pServiceRunning()) {
918 WIFI_LOGE("P2pService is not running!");
919 return WIFI_OPT_P2P_NOT_OPENED;
920 }
921
922 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
923 if (pService == nullptr) {
924 WIFI_LOGE("Get P2P service failed!");
925 return WIFI_OPT_P2P_NOT_OPENED;
926 }
927 ErrCode errCode = pService->QueryP2pGroups(groups);
928 #ifdef SUPPORT_RANDOM_MAC_ADDR
929 if (WifiPermissionUtils::VerifyGetWifiPeersMacPermission() == PERMISSION_DENIED) {
930 WIFI_LOGI("%{public}s: GET_WIFI_PEERS_MAC PERMISSION_DENIED", __func__);
931 for (auto group = groups.begin(); group != groups.end(); ++group) {
932 WifiMacAddrInfo ownMacAddrInfo;
933 WifiP2pDevice owner = group->GetOwner();
934 ownMacAddrInfo.bssid = owner.GetDeviceAddress();
935 ownMacAddrInfo.bssidType = owner.GetDeviceAddressType();
936 std::string ownRandomMacAddr =
937 WifiConfigCenter::GetInstance().GetMacAddrPairs(WifiMacAddrInfoType::P2P_GROUPSINFO_MACADDR_INFO,
938 ownMacAddrInfo);
939 if (!ownRandomMacAddr.empty() &&
940 (ownMacAddrInfo.bssidType == REAL_DEVICE_ADDRESS)) {
941 owner.SetDeviceAddress(ownRandomMacAddr);
942 owner.SetDeviceAddressType(RANDOM_DEVICE_ADDRESS);
943 group->SetOwner(owner);
944
945 std::vector<WifiP2pDevice> vecClientDevice = group->GetClientDevices();
946 for (auto iter = vecClientDevice.begin(); iter != vecClientDevice.end(); ++iter) {
947 WifiMacAddrInfo clientMacAddrInfo;
948 clientMacAddrInfo.bssid = iter->GetDeviceAddress();
949 clientMacAddrInfo.bssidType = iter->GetDeviceAddressType();
950 std::string clientRandomMacAddr = WifiConfigCenter::GetInstance().GetMacAddrPairs(
951 WifiMacAddrInfoType::P2P_GROUPSINFO_MACADDR_INFO, clientMacAddrInfo);
952 if (!clientRandomMacAddr.empty() &&
953 (clientMacAddrInfo.bssidType == REAL_DEVICE_ADDRESS)) {
954 iter->SetDeviceAddress(clientRandomMacAddr);
955 iter->SetDeviceAddressType(RANDOM_DEVICE_ADDRESS);
956 WIFI_LOGI("%{public}s: the record is updated, bssid:%{private}s, bssidType:%{public}d",
957 __func__, iter->GetDeviceAddress().c_str(), iter->GetDeviceAddressType());
958 }
959 }
960 group->SetClientDevices(vecClientDevice);
961 }
962 }
963 }
964 #endif
965 return errCode;
966 }
967
QueryP2pServices(std::vector<WifiP2pServiceInfo> & services)968 ErrCode WifiP2pServiceImpl::QueryP2pServices(std::vector<WifiP2pServiceInfo> &services)
969 {
970 WIFI_LOGI("QueryP2pServices");
971 if (WifiPermissionUtils::VerifyGetWifiInfoInternalPermission() == PERMISSION_DENIED) {
972 WIFI_LOGE("QueryP2pServices:VerifyGetWifiInfoInternalPermission PERMISSION_DENIED!");
973 return WIFI_OPT_PERMISSION_DENIED;
974 }
975 if (!IsP2pServiceRunning()) {
976 WIFI_LOGE("P2pService is not running!");
977 return WIFI_OPT_P2P_NOT_OPENED;
978 }
979
980 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
981 if (pService == nullptr) {
982 WIFI_LOGE("Get P2P service failed!");
983 return WIFI_OPT_P2P_NOT_OPENED;
984 }
985 return pService->QueryP2pServices(services);
986 }
987
RegisterCallBack(const sptr<IWifiP2pCallback> & callback,const std::vector<std::string> & event)988 ErrCode WifiP2pServiceImpl::RegisterCallBack(const sptr<IWifiP2pCallback> &callback,
989 const std::vector<std::string> &event)
990 {
991 WIFI_LOGI("WifiP2pServiceImpl::RegisterCallBack!");
992 WifiInternalEventDispatcher::GetInstance().SetSingleP2pCallback(callback);
993 return WIFI_OPT_SUCCESS;
994 }
995
GetSupportedFeatures(long & features)996 ErrCode WifiP2pServiceImpl::GetSupportedFeatures(long &features)
997 {
998 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
999 WIFI_LOGE("GetSupportedFeatures:VerifyGetWifiInfoPermission() PERMISSION_DENIED!");
1000 return WIFI_OPT_PERMISSION_DENIED;
1001 }
1002 int ret = WifiManager::GetInstance().GetSupportedFeatures(features);
1003 if (ret < 0) {
1004 WIFI_LOGE("Failed to get supported features!");
1005 return WIFI_OPT_FAILED;
1006 }
1007 return WIFI_OPT_SUCCESS;
1008 }
1009
IsCallingAllowed()1010 bool WifiP2pServiceImpl::IsCallingAllowed()
1011 {
1012 auto state = WifiConfigCenter::GetInstance().GetWifiDetailState();
1013 if (state == WifiDetailState::STATE_SEMI_ACTIVE && !WifiAuthCenter::IsSystemAccess()) {
1014 WIFI_LOGW("curr wifi state is semiactive, only allow system app use p2p service");
1015 return false;
1016 }
1017 return true;
1018 }
1019
IsP2pServiceRunning()1020 bool WifiP2pServiceImpl::IsP2pServiceRunning()
1021 {
1022 if (!IsCallingAllowed()) {
1023 return false;
1024 }
1025 WifiOprMidState curState = WifiConfigCenter::GetInstance().GetP2pMidState();
1026 if (curState != WifiOprMidState::RUNNING) {
1027 WIFI_LOGW("p2p service does not started!");
1028 return false;
1029 }
1030 return true;
1031 }
1032
SetP2pDeviceName(const std::string & deviceName)1033 ErrCode WifiP2pServiceImpl::SetP2pDeviceName(const std::string &deviceName)
1034 {
1035 WIFI_LOGI("SetP2pDeviceName:%{public}s", deviceName.c_str());
1036 if (!WifiAuthCenter::IsSystemAccess()) {
1037 WIFI_LOGE("SetP2pDeviceName:NOT System APP, PERMISSION_DENIED!");
1038 return WIFI_OPT_NON_SYSTEMAPP;
1039 }
1040 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1041 WIFI_LOGE("SetP2pDeviceName:VerifySetWifiInfoPermission PERMISSION_DENIED!");
1042 return WIFI_OPT_PERMISSION_DENIED;
1043 }
1044
1045 if (WifiPermissionUtils::VerifyWifiConnectionPermission() == PERMISSION_DENIED) {
1046 WIFI_LOGE("SetP2pDeviceName:VerifyWifiConnectionPermission PERMISSION_DENIED!");
1047 return WIFI_OPT_PERMISSION_DENIED;
1048 }
1049
1050 uint32_t length = deviceName.length();
1051 if (length > DEVICE_NAME_LENGTH || length < 0) {
1052 return WIFI_OPT_INVALID_PARAM;
1053 }
1054 WifiSettings::GetInstance().SetP2pDeviceName(deviceName);
1055 if (!IsP2pServiceRunning()) {
1056 WIFI_LOGE("P2pService is not running!");
1057 return WIFI_OPT_SUCCESS;
1058 }
1059 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1060 if (pService == nullptr) {
1061 WIFI_LOGE("Get P2P service failed!");
1062 return WIFI_OPT_P2P_NOT_OPENED;
1063 }
1064 return pService->SetP2pDeviceName(deviceName);
1065 }
1066
SetP2pWfdInfo(const WifiP2pWfdInfo & wfdInfo)1067 ErrCode WifiP2pServiceImpl::SetP2pWfdInfo(const WifiP2pWfdInfo &wfdInfo)
1068 {
1069 WIFI_LOGI("SetP2pWfdInfo");
1070 if (WifiPermissionUtils::VerifyGetWifiInfoInternalPermission() == PERMISSION_DENIED) {
1071 WIFI_LOGE("SetP2pWfdInfo:VerifyGetWifiInfoInternalPermission PERMISSION_DENIED!");
1072 return WIFI_OPT_PERMISSION_DENIED;
1073 }
1074 if (!IsP2pServiceRunning()) {
1075 WIFI_LOGE("P2pService is not running!");
1076 return WIFI_OPT_P2P_NOT_OPENED;
1077 }
1078 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1079 if (pService == nullptr) {
1080 WIFI_LOGE("Get P2P service failed!");
1081 return WIFI_OPT_P2P_NOT_OPENED;
1082 }
1083 return pService->SetP2pWfdInfo(wfdInfo);
1084 }
1085
Hid2dRequestGcIp(const std::string & gcMac,std::string & ipAddr)1086 ErrCode WifiP2pServiceImpl::Hid2dRequestGcIp(const std::string& gcMac, std::string& ipAddr)
1087 {
1088 WIFI_LOGI("Hid2dRequestGcIp");
1089 int callingUid = GetCallingUid();
1090 if (callingUid != SOFT_BUS_SERVICE_UID) {
1091 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1092 return WIFI_OPT_PERMISSION_DENIED;
1093 }
1094 if (!WifiAuthCenter::IsNativeProcess()) {
1095 WIFI_LOGE("Hid2dRequestGcIp:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1096 return WIFI_OPT_PERMISSION_DENIED;
1097 }
1098 if (!IsP2pServiceRunning()) {
1099 WIFI_LOGE("P2pService is not runing!");
1100 return WIFI_OPT_P2P_NOT_OPENED;
1101 }
1102 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1103 if (pService == nullptr) {
1104 WIFI_LOGE("Get P2P service failed!");
1105 return WIFI_OPT_P2P_NOT_OPENED;
1106 }
1107 return pService->Hid2dRequestGcIp(gcMac, ipAddr);
1108 }
1109
Hid2dSharedlinkIncrease()1110 ErrCode WifiP2pServiceImpl::Hid2dSharedlinkIncrease()
1111 {
1112 int callingUid = GetCallingUid();
1113 WIFI_LOGI("Uid %{public}d Hid2dSharedlinkIncrease", callingUid);
1114 if (callingUid != SOFT_BUS_SERVICE_UID) {
1115 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1116 return WIFI_OPT_PERMISSION_DENIED;
1117 }
1118 if (!WifiAuthCenter::IsNativeProcess()) {
1119 WIFI_LOGE("Hid2dSharedlinkIncrease:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1120 return WIFI_OPT_PERMISSION_DENIED;
1121 }
1122 int status = static_cast<int>(P2pConnectedState::P2P_DISCONNECTED);
1123 ErrCode ret = GetP2pConnectedStatus(status);
1124 if (ret != WIFI_OPT_SUCCESS) {
1125 WIFI_LOGI("Hid2dSharedlinkIncrease get P2P connect status error!");
1126 return ret;
1127 }
1128 if (status != static_cast<int>(P2pConnectedState::P2P_CONNECTED)) {
1129 WIFI_LOGE("Hid2dSharedlinkIncrease P2P not in connected state!");
1130 return WIFI_OPT_FAILED;
1131 }
1132 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1133 if (pService == nullptr) {
1134 WIFI_LOGE("Get P2P service failed!");
1135 return WIFI_OPT_FAILED;
1136 }
1137 pService->IncreaseSharedLink(callingUid);
1138 return WIFI_OPT_SUCCESS;
1139 }
1140
Hid2dSharedlinkDecrease()1141 ErrCode WifiP2pServiceImpl::Hid2dSharedlinkDecrease()
1142 {
1143 int callingUid = GetCallingUid();
1144 WIFI_LOGI("Uid %{public}d Hid2dSharedlinkDecrease", callingUid);
1145 if (callingUid != SOFT_BUS_SERVICE_UID) {
1146 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1147 return WIFI_OPT_PERMISSION_DENIED;
1148 }
1149 if (!WifiAuthCenter::IsNativeProcess()) {
1150 WIFI_LOGE("Hid2dSharedlinkDecrease:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1151 return WIFI_OPT_PERMISSION_DENIED;
1152 }
1153 if (!IsP2pServiceRunning()) {
1154 WIFI_LOGE("P2pService is not runing!");
1155 return WIFI_OPT_P2P_NOT_OPENED;
1156 }
1157 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1158 if (pService == nullptr) {
1159 WIFI_LOGE("Get P2P service failed!");
1160 return WIFI_OPT_P2P_NOT_OPENED;
1161 }
1162 pService->DecreaseSharedLink(callingUid);
1163 return WIFI_OPT_SUCCESS;
1164 }
1165
Hid2dCreateGroup(const int frequency,FreqType type)1166 ErrCode WifiP2pServiceImpl::Hid2dCreateGroup(const int frequency, FreqType type)
1167 {
1168 int callingUid = GetCallingUid();
1169 WIFI_LOGI("Uid %{public}d Hid2dCreateGroup", callingUid);
1170 if (callingUid != SOFT_BUS_SERVICE_UID) {
1171 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1172 return WIFI_OPT_PERMISSION_DENIED;
1173 }
1174 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1175 WIFI_LOGE("CreateGroup:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1176 return WIFI_OPT_PERMISSION_DENIED;
1177 }
1178
1179 if (!IsP2pServiceRunning()) {
1180 WIFI_LOGE("P2pService is not running!");
1181 return WIFI_OPT_P2P_NOT_OPENED;
1182 }
1183
1184 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1185 if (pService == nullptr) {
1186 WIFI_LOGE("Get P2P service failed!");
1187 return WIFI_OPT_P2P_NOT_OPENED;
1188 }
1189 WifiConfigCenter::GetInstance().SetP2pBusinessType(P2pBusinessType::P2P_TYPE_HID2D);
1190 return pService->Hid2dCreateGroup(frequency, type);
1191 }
1192
Hid2dRemoveGcGroup(const std::string & gcIfName)1193 ErrCode WifiP2pServiceImpl::Hid2dRemoveGcGroup(const std::string& gcIfName)
1194 {
1195 WIFI_LOGI("Hid2dRemoveGcGroup:, gcIfName: %{public}s", gcIfName.c_str());
1196 // TO Imple: delete by interface
1197 int callingUid = GetCallingUid();
1198 if (callingUid != SOFT_BUS_SERVICE_UID) {
1199 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1200 return WIFI_OPT_PERMISSION_DENIED;
1201 }
1202 return RemoveGroup();
1203 }
1204
Hid2dConnect(const Hid2dConnectConfig & config)1205 ErrCode WifiP2pServiceImpl::Hid2dConnect(const Hid2dConnectConfig& config)
1206 {
1207 int callingUid = GetCallingUid();
1208 WIFI_LOGI("Uid %{public}d Hid2dConnect", callingUid);
1209 if (callingUid != SOFT_BUS_SERVICE_UID) {
1210 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1211 return WIFI_OPT_PERMISSION_DENIED;
1212 }
1213 if (WifiPermissionUtils::VerifyGetWifiDirectDevicePermission() == PERMISSION_DENIED) {
1214 WIFI_LOGE("Hid2dConnect:VerifyGetWifiDirectDevicePermission PERMISSION_DENIED!");
1215 return WIFI_OPT_PERMISSION_DENIED;
1216 }
1217
1218 if (!IsP2pServiceRunning()) {
1219 WIFI_LOGE("P2pService is not running!");
1220 return WIFI_OPT_P2P_NOT_OPENED;
1221 }
1222
1223 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1224 if (pService == nullptr) {
1225 WIFI_LOGE("Get P2P service failed!");
1226 return WIFI_OPT_P2P_NOT_OPENED;
1227 }
1228 WifiConfigCenter::GetInstance().SetP2pBusinessType(P2pBusinessType::P2P_TYPE_HID2D);
1229 WriteP2pKpiCountHiSysEvent(static_cast<int>(P2P_CHR_EVENT::MAGICLINK_CNT));
1230 return pService->Hid2dConnect(config);
1231 }
1232
Hid2dConfigIPAddr(const std::string & ifName,const IpAddrInfo & ipInfo)1233 ErrCode WifiP2pServiceImpl::Hid2dConfigIPAddr(const std::string& ifName, const IpAddrInfo& ipInfo)
1234 {
1235 WIFI_LOGI("Hid2dConfigIPAddr, ifName: %{public}s", ifName.c_str());
1236 int callingUid = GetCallingUid();
1237 if (callingUid != SOFT_BUS_SERVICE_UID) {
1238 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1239 return WIFI_OPT_PERMISSION_DENIED;
1240 }
1241 if (!WifiAuthCenter::IsNativeProcess()) {
1242 WIFI_LOGE("Hid2dConfigIPAddr:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1243 return WIFI_OPT_PERMISSION_DENIED;
1244 }
1245 IfConfig::GetInstance().AddIpAddr(ifName, ipInfo.ip, ipInfo.netmask, IpType::IPTYPE_IPV4);
1246 WifiNetAgent::GetInstance().AddRoute(ifName, ipInfo.ip, IpTools::GetMaskLength(ipInfo.netmask));
1247 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1248 if (pService == nullptr) {
1249 WIFI_LOGE("Get P2P service failed!");
1250 return WIFI_OPT_P2P_NOT_OPENED;
1251 }
1252 ErrCode ret = pService->SetGcIpAddress(ipInfo);
1253 return ret;
1254 }
1255
Hid2dReleaseIPAddr(const std::string & ifName)1256 ErrCode WifiP2pServiceImpl::Hid2dReleaseIPAddr(const std::string& ifName)
1257 {
1258 WIFI_LOGI("Hid2dReleaseIPAddr");
1259 int callingUid = GetCallingUid();
1260 if (callingUid != SOFT_BUS_SERVICE_UID) {
1261 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1262 return WIFI_OPT_PERMISSION_DENIED;
1263 }
1264 if (!WifiAuthCenter::IsNativeProcess()) {
1265 WIFI_LOGE("Hid2dReleaseIPAddr:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1266 return WIFI_OPT_PERMISSION_DENIED;
1267 }
1268 IfConfig::GetInstance().FlushIpAddr(ifName, IpType::IPTYPE_IPV4);
1269 return WIFI_OPT_SUCCESS;
1270 }
1271
Hid2dGetRecommendChannel(const RecommendChannelRequest & request,RecommendChannelResponse & response)1272 ErrCode WifiP2pServiceImpl::Hid2dGetRecommendChannel(const RecommendChannelRequest& request,
1273 RecommendChannelResponse& response)
1274 {
1275 WIFI_LOGI("Hid2dGetRecommendChannel");
1276 int callingUid = GetCallingUid();
1277 if (callingUid != SOFT_BUS_SERVICE_UID) {
1278 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1279 return WIFI_OPT_PERMISSION_DENIED;
1280 }
1281 if (!WifiAuthCenter::IsNativeProcess()) {
1282 WIFI_LOGE("Hid2dGetRecommendChannel:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1283 return WIFI_OPT_PERMISSION_DENIED;
1284 }
1285 if (!IsP2pServiceRunning()) {
1286 WIFI_LOGE("P2pService is not runing!");
1287 return WIFI_OPT_P2P_NOT_OPENED;
1288 }
1289 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1290 if (pService == nullptr) {
1291 WIFI_LOGE("Get P2P service failed!");
1292 return WIFI_OPT_P2P_NOT_OPENED;
1293 }
1294 int channel = pService->GetP2pRecommendChannel();
1295 int freq = ChannelToFrequency(channel);
1296 WIFI_LOGI("Get recommended channel: %{public}d, freq: %{public}d", channel, freq);
1297 if (channel == 0) {
1298 WriteP2pKpiCountHiSysEvent(static_cast<int>(P2P_CHR_EVENT::P2P_SUC_2G4_CNT));
1299 } else {
1300 WriteP2pKpiCountHiSysEvent(static_cast<int>(P2P_CHR_EVENT::P2P_SUC_5G_CNT));
1301 }
1302 response.centerFreq = freq;
1303 response.status = RecommendStatus::RS_SUCCESS;
1304 return WIFI_OPT_SUCCESS;
1305 }
1306
Hid2dGetChannelListFor5G(std::vector<int> & vecChannelList)1307 ErrCode WifiP2pServiceImpl::Hid2dGetChannelListFor5G(std::vector<int>& vecChannelList)
1308 {
1309 WIFI_LOGI("Hid2dGetChannelListFor5G");
1310 int callingUid = GetCallingUid();
1311 if (callingUid != SOFT_BUS_SERVICE_UID) {
1312 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1313 return WIFI_OPT_PERMISSION_DENIED;
1314 }
1315 if (!WifiAuthCenter::IsNativeProcess()) {
1316 WIFI_LOGE("Hid2dGetChannelListFor5G:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1317 return WIFI_OPT_PERMISSION_DENIED;
1318 }
1319 ChannelsTable channels;
1320 WifiChannelHelper::GetInstance().GetValidChannels(channels);
1321 if (channels.find(BandType::BAND_5GHZ) != channels.end()) {
1322 vecChannelList = channels[BandType::BAND_5GHZ];
1323 }
1324
1325 if (vecChannelList.size() == 0) {
1326 std::vector<int> tempFrequenciesList;
1327 WifiSettings::GetInstance().SetDefaultFrequenciesByCountryBand(BandType::BAND_5GHZ, tempFrequenciesList);
1328 TransformFrequencyIntoChannel(tempFrequenciesList, vecChannelList);
1329 }
1330 std::string strChannel;
1331 for (auto channel : vecChannelList) {
1332 strChannel += std::to_string(channel) + ",";
1333 }
1334 WIFI_LOGI("5G channel list[%{public}d]: %{public}s",
1335 (int)vecChannelList.size(), strChannel.c_str());
1336 return WIFI_OPT_SUCCESS;
1337 }
1338
Hid2dGetSelfWifiCfgInfo(SelfCfgType cfgType,char cfgData[CFG_DATA_MAX_BYTES],int * getDatValidLen)1339 ErrCode WifiP2pServiceImpl::Hid2dGetSelfWifiCfgInfo(SelfCfgType cfgType,
1340 char cfgData[CFG_DATA_MAX_BYTES], int* getDatValidLen)
1341 {
1342 WIFI_LOGI("Hid2dGetSelfWifiCfgInfo");
1343 int callingUid = GetCallingUid();
1344 if (callingUid != SOFT_BUS_SERVICE_UID) {
1345 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1346 return WIFI_OPT_PERMISSION_DENIED;
1347 }
1348 if (!WifiAuthCenter::IsNativeProcess()) {
1349 WIFI_LOGE("Hid2dGetSelfWifiCfgInfo:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1350 return WIFI_OPT_PERMISSION_DENIED;
1351 }
1352 if (!IsP2pServiceRunning()) {
1353 WIFI_LOGE("P2pService is not runing!");
1354 return WIFI_OPT_P2P_NOT_OPENED;
1355 }
1356
1357 IEnhanceService *pEnhanceService = WifiServiceManager::GetInstance().GetEnhanceServiceInst();
1358 if (pEnhanceService == nullptr) {
1359 WIFI_LOGE("Get pEnhanceService service failed!");
1360 *getDatValidLen = 0;
1361 return WIFI_OPT_GET_ENHANCE_SVC_FAILED;
1362 }
1363
1364 if (pEnhanceService->Hid2dGetSelfWifiCfgInfo(cfgType, cfgData, getDatValidLen) != WIFI_OPT_SUCCESS) {
1365 WIFI_LOGE("Hid2dGetSelfWifiCfgInfo failed");
1366 return WIFI_OPT_FAILED;
1367 }
1368 return WIFI_OPT_SUCCESS;
1369 }
1370
Hid2dSetPeerWifiCfgInfo(PeerCfgType cfgType,char cfgData[CFG_DATA_MAX_BYTES],int setDataValidLen)1371 ErrCode WifiP2pServiceImpl::Hid2dSetPeerWifiCfgInfo(PeerCfgType cfgType,
1372 char cfgData[CFG_DATA_MAX_BYTES], int setDataValidLen)
1373 {
1374 WIFI_LOGI("Hid2dSetPeerWifiCfgInfo");
1375 int callingUid = GetCallingUid();
1376 if (callingUid != SOFT_BUS_SERVICE_UID) {
1377 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1378 return WIFI_OPT_PERMISSION_DENIED;
1379 }
1380 if (!WifiAuthCenter::IsNativeProcess()) {
1381 WIFI_LOGE("Hid2dSetPeerWifiCfgInfo:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1382 return WIFI_OPT_PERMISSION_DENIED;
1383 }
1384 if (!IsP2pServiceRunning()) {
1385 WIFI_LOGE("P2pService is not runing!");
1386 return WIFI_OPT_P2P_NOT_OPENED;
1387 }
1388
1389 IEnhanceService *pEnhanceService = WifiServiceManager::GetInstance().GetEnhanceServiceInst();
1390 if (pEnhanceService == nullptr) {
1391 WIFI_LOGE("Get pEnhanceService service failed!");
1392 return WIFI_OPT_GET_ENHANCE_SVC_FAILED;
1393 }
1394
1395 if (pEnhanceService->Hid2dSetPeerWifiCfgInfo(cfgType, cfgData, setDataValidLen) != WIFI_OPT_SUCCESS) {
1396 WIFI_LOGE("Hid2dSetPeerWifiCfgInfo failed");
1397 return WIFI_OPT_FAILED;
1398 }
1399 return WIFI_OPT_SUCCESS;
1400 }
1401
Hid2dSetUpperScene(const std::string & ifName,const Hid2dUpperScene & scene)1402 ErrCode WifiP2pServiceImpl::Hid2dSetUpperScene(const std::string& ifName, const Hid2dUpperScene& scene)
1403 {
1404 WIFI_LOGI("Hid2dSetUpperScene");
1405 int callingUid = GetCallingUid();
1406 if (callingUid != SOFT_BUS_SERVICE_UID && callingUid != CAST_ENGINE_SERVICE_UID &&
1407 callingUid != MIRACAST_SERVICE_UID && callingUid != SHARE_SERVICE_UID &&
1408 callingUid != MOUSE_CROSS_SERVICE_UID) {
1409 WIFI_LOGE("%{public}s, permission denied! uid = %{public}d", __func__, callingUid);
1410 return WIFI_OPT_PERMISSION_DENIED;
1411 }
1412 if (!WifiAuthCenter::IsNativeProcess()) {
1413 WIFI_LOGE("Hid2dSetUpperScene:NOT NATIVE PROCESS, PERMISSION_DENIED!");
1414 return WIFI_OPT_PERMISSION_DENIED;
1415 }
1416 if (!IsP2pServiceRunning()) {
1417 WIFI_LOGE("P2pService is not runing!");
1418 return WIFI_OPT_P2P_NOT_OPENED;
1419 }
1420
1421 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1422 if (pService == nullptr) {
1423 WIFI_LOGE("Get P2P service failed!");
1424 return WIFI_OPT_P2P_NOT_OPENED;
1425 }
1426 WifiConfigCenter::GetInstance().SetHid2dUpperScene(callingUid, scene);
1427 return pService->Hid2dSetUpperScene(ifName, scene);
1428 }
1429
MonitorCfgChange(void)1430 ErrCode WifiP2pServiceImpl::MonitorCfgChange(void)
1431 {
1432 WIFI_LOGI("MonitorCfgChange");
1433 if (!IsP2pServiceRunning()) {
1434 WIFI_LOGE("P2pService is not runing!");
1435 return WIFI_OPT_P2P_NOT_OPENED;
1436 }
1437
1438 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1439 if (pService == nullptr) {
1440 WIFI_LOGE("Get P2P service failed!");
1441 return WIFI_OPT_P2P_NOT_OPENED;
1442 }
1443 return pService->MonitorCfgChange();
1444 }
1445
SaBasicDump(std::string & result)1446 void WifiP2pServiceImpl::SaBasicDump(std::string& result)
1447 {
1448 result.append("P2P enable status: ");
1449 int status = WifiConfigCenter::GetInstance().GetP2pState();
1450 std::string strStatus = (status == static_cast<int>(P2pState::P2P_STATE_STARTED)) ? "enable" : "disable";
1451 result.append(strStatus);
1452 result += "\n";
1453 }
1454
Dump(int32_t fd,const std::vector<std::u16string> & args)1455 int32_t WifiP2pServiceImpl::Dump(int32_t fd, const std::vector<std::u16string>& args)
1456 {
1457 WIFI_LOGI("Enter p2p dump func.");
1458 std::vector<std::string> vecArgs;
1459 std::transform(args.begin(), args.end(), std::back_inserter(vecArgs), [](const std::u16string &arg) {
1460 return Str16ToStr8(arg);
1461 });
1462
1463 WifiDumper dumper;
1464 std::string result;
1465 dumper.P2pDump(SaBasicDump, vecArgs, result);
1466 if (!SaveStringToFd(fd, result)) {
1467 WIFI_LOGE("WiFi P2p save string to fd failed.");
1468 return ERR_OK;
1469 }
1470 return ERR_OK;
1471 }
1472
DiscoverPeers(int32_t channelid)1473 ErrCode WifiP2pServiceImpl::DiscoverPeers(int32_t channelid)
1474 {
1475 WIFI_LOGE("DiscoverPeers");
1476 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1477 WIFI_LOGE("DiscoverPeers:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1478 return WIFI_OPT_PERMISSION_DENIED;
1479 }
1480 if (!IsP2pServiceRunning()) {
1481 WIFI_LOGE("P2pService is not running!");
1482 return WIFI_OPT_P2P_NOT_OPENED;
1483 }
1484
1485 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1486 if (pService == nullptr) {
1487 WIFI_LOGE("Get P2P service failed!");
1488 return WIFI_OPT_P2P_NOT_OPENED;
1489 }
1490 return pService->DiscoverPeers(channelid);
1491 }
1492
DisableRandomMac(int setmode)1493 ErrCode WifiP2pServiceImpl::DisableRandomMac(int setmode)
1494 {
1495 WIFI_LOGE("DisableRandomMac");
1496 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1497 WIFI_LOGE("DisableRandomMac:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1498 return WIFI_OPT_PERMISSION_DENIED;
1499 }
1500
1501 if (!IsP2pServiceRunning()) {
1502 WIFI_LOGE("P2pService is not running!");
1503 return WIFI_OPT_P2P_NOT_OPENED;
1504 }
1505
1506 IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
1507 if (pService == nullptr) {
1508 WIFI_LOGE("Get P2P service failed!");
1509 return WIFI_OPT_P2P_NOT_OPENED;
1510 }
1511 return pService->DisableRandomMac(setmode);
1512 }
1513
CheckCanUseP2p()1514 ErrCode WifiP2pServiceImpl::CheckCanUseP2p()
1515 {
1516 if (WifiPermissionUtils::VerifySetWifiInfoPermission() == PERMISSION_DENIED) {
1517 WIFI_LOGE("CheckCanUseP2p: VerifySetWifiInfoPermission PERMISSION_DENIED!");
1518 return WIFI_OPT_PERMISSION_DENIED;
1519 }
1520
1521 if (WifiManager::GetInstance().GetWifiMultiVapManager() == nullptr) {
1522 WIFI_LOGE("CheckCanUseP2p: WifiMultiVapManager is nullptr!");
1523 return WIFI_OPT_FAILED;
1524 }
1525
1526 return ((WifiManager::GetInstance().GetWifiMultiVapManager()->CheckCanUseP2p()) ? WIFI_OPT_SUCCESS
1527 : WIFI_OPT_NOT_SUPPORTED);
1528 }
1529
IsRemoteDied(void)1530 bool WifiP2pServiceImpl::IsRemoteDied(void)
1531 {
1532 return false;
1533 }
1534
Hid2dIsWideBandwidthSupported(bool & isSupport)1535 ErrCode WifiP2pServiceImpl::Hid2dIsWideBandwidthSupported(bool &isSupport)
1536 {
1537 if (WifiPermissionUtils::VerifyGetWifiInfoPermission() == PERMISSION_DENIED) {
1538 WIFI_LOGE("Hid2dIsWideBandwidthSupported:VerifyGetWifiInfoPermission PERMISSION_DENIED!");
1539 return WIFI_OPT_PERMISSION_DENIED;
1540 }
1541
1542 IEnhanceService *pEnhanceService = WifiServiceManager::GetInstance().GetEnhanceServiceInst();
1543 if (pEnhanceService == nullptr) {
1544 WIFI_LOGE("Hid2dIsWideBandwidthSupported get pEnhanceService service failed!");
1545 return WIFI_OPT_GET_ENHANCE_SVC_FAILED;
1546 }
1547
1548 isSupport = pEnhanceService->IsWideBandwidthSupported();
1549 if (!isSupport) {
1550 WIFI_LOGE("Hid2dIsWideBandwidthSupported IsWideBandwidthSupported is false");
1551 return WIFI_OPT_FAILED;
1552 }
1553 return WIFI_OPT_SUCCESS;
1554 }
1555 } // namespace Wifi
1556 } // namespace OHOS
1557