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 #include "p2p_monitor.h"
16 #include <climits>
17 #include "wifi_p2p_hal_interface.h"
18 #include "dhcpd_interface.h"
19 #include "wifi_logger.h"
20 #include "wifi_common_util.h"
21 #include "p2p_define.h"
22 #include "wifi_hisysevent.h"
23 #include "wifi_event_callback.h"
24
25 DEFINE_WIFILOG_P2P_LABEL("P2pMonitor");
26
27 namespace OHOS {
28 namespace Wifi {
P2pMonitor()29 P2pMonitor::P2pMonitor() : selectIfacName(), setMonitorIface(), mapHandler()
30 {}
31
~P2pMonitor()32 P2pMonitor::~P2pMonitor() __attribute__((no_sanitize("cfi")))
33 {
34 P2pHalCallback callback;
35 WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
36 setMonitorIface.clear();
37 }
38
Initialize()39 void P2pMonitor::Initialize()
40 {}
41
MonitorBegins(const std::string & iface)42 void P2pMonitor::MonitorBegins(const std::string &iface)
43 {
44 using namespace std::placeholders;
45 selectIfacName = iface;
46 setMonitorIface.insert(iface);
47
48 P2pHalCallback callback = {
49 std::bind(&P2pMonitor::OnConnectSupplicant, this, _1),
50 std::bind(&P2pMonitor::WpaEventDeviceFound, this, _1),
51 std::bind(&P2pMonitor::WpaEventDeviceLost, this, _1),
52 std::bind(&P2pMonitor::WpaEventGoNegRequest, this, _1, _2),
53 std::bind(&P2pMonitor::WpaEventGoNegSuccess, this),
54 std::bind(&P2pMonitor::WpaEventGoNegFailure, this, _1),
55 std::bind(&P2pMonitor::WpaEventInvitationReceived, this, _1),
56 std::bind(&P2pMonitor::WpaEventInvitationResult, this, _1, _2),
57 std::bind(&P2pMonitor::WpaEventGroupFormationSuccess, this),
58 std::bind(&P2pMonitor::WpaEventGroupFormationFailure, this, _1),
59 std::bind(&P2pMonitor::WpaEventGroupStarted, this, _1),
60 std::bind(&P2pMonitor::WpaEventGroupRemoved, this, _1, _2),
61 std::bind(&P2pMonitor::WpaEventProvDiscPbcReq, this, _1),
62 std::bind(&P2pMonitor::WpaEventProvDiscPbcResp, this, _1),
63 std::bind(&P2pMonitor::WpaEventProvDiscEnterPin, this, _1),
64 std::bind(&P2pMonitor::WpaEventProvDiscShowPin, this, _1, _2),
65 std::bind(&P2pMonitor::WpaEventProvDiscFailure, this),
66 std::bind(&P2pMonitor::WpaEventFindStopped, this),
67 std::bind(&P2pMonitor::WpaEventServDiscResp, this, _1, _2, _3),
68 std::bind(&P2pMonitor::WpaEventApStaDisconnected, this, _1),
69 std::bind(&P2pMonitor::WpaEventApStaConnected, this, _1, _2),
70 std::bind(&P2pMonitor::OnConnectSupplicantFailed, this),
71 std::bind(&P2pMonitor::WpaEventServDiscReq, this, _1),
72 std::bind(&P2pMonitor::WpaEventP2pIfaceCreated, this, _1, _2),
73 std::bind(&P2pMonitor::WpaEventP2pConnectFailed, this, _1, _2),
74 std::bind(&P2pMonitor::WpaEventP2pChannelSwitch, this, _1),
75 std::bind(&P2pMonitor::WpaEventStaNotifyCallBack, this, _1),
76 };
77
78 WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
79 }
80
MonitorEnds(const std::string & iface)81 void P2pMonitor::MonitorEnds(const std::string &iface)
82 {
83 P2pHalCallback callback;
84 WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
85 setMonitorIface.erase(iface);
86 }
87
RegisterIfaceHandler(const std::string & iface,const std::function<HandlerMethod> & handler)88 void P2pMonitor::RegisterIfaceHandler(const std::string &iface, const std::function<HandlerMethod> &handler)
89 {
90 auto iter = mapHandler.find(iface);
91 if (iter != mapHandler.end()) {
92 iter->second = handler;
93 } else {
94 mapHandler.emplace(std::make_pair(iface, handler));
95 }
96 }
97
UnregisterHandler(const std::string & iface)98 void P2pMonitor::UnregisterHandler(const std::string &iface)
99 {
100 auto iter = mapHandler.find(iface);
101 if (iter != mapHandler.end()) {
102 mapHandler.erase(iter);
103 }
104 }
105
MessageToStateMachine(const std::string & iface,P2P_STATE_MACHINE_CMD msgName,int param1,int param2,const std::any & messageObj) const106 void P2pMonitor::MessageToStateMachine(
107 const std::string &iface, P2P_STATE_MACHINE_CMD msgName, int param1, int param2, const std::any &messageObj) const
108 {
109 if (setMonitorIface.count(iface) > 0) {
110 auto iter = mapHandler.find(iface);
111 if (iter != mapHandler.end()) {
112 WIFI_LOGI("P2p Monitor event: iface [%{public}s], eventID [%{public}d]",
113 iface.c_str(),
114 static_cast<int>(msgName));
115 const auto &handler = iter->second;
116 handler(msgName, param1, param2, messageObj);
117 } else {
118 WIFI_LOGE("iface: %{private}s is not register handler.", iface.c_str());
119 }
120 } else {
121 WIFI_LOGW("iface: %{public}s is not monitor.", iface.c_str());
122 }
123 }
124
IntStatusToP2pStatus(int status) const125 P2pStatus P2pMonitor::IntStatusToP2pStatus(int status) const
126 {
127 std::map<P2pStatusCode, P2pStatus> translateMap;
128 translateMap.insert(std::make_pair(P2pStatusCode::SUCCESS, P2pStatus::SUCCESS));
129 translateMap.insert(std::make_pair(P2pStatusCode::SUCCESS_DEFERRED, P2pStatus::SUCCESS));
130 translateMap.insert(std::make_pair(
131 P2pStatusCode::FAIL_INFORMATION_IS_CURRENTLY_UNAVAILABLE, P2pStatus::INFORMATION_IS_CURRENTLY_UNAVAILABLE));
132 translateMap.insert(
133 std::make_pair(P2pStatusCode::FAIL_INCOMPATIBLE_PARAMETERS, P2pStatus::INCOMPATIBLE_PARAMETERS));
134 translateMap.insert(std::make_pair(P2pStatusCode::FAIL_LIMIT_REACHED, P2pStatus::LIMIT_REACHED));
135 translateMap.insert(std::make_pair(P2pStatusCode::FAIL_INVALID_PARAMETERS, P2pStatus::INVALID_PARAMETERS));
136 translateMap.insert(
137 std::make_pair(P2pStatusCode::FAIL_UNABLE_TO_ACCOMMODATE_REQUEST, P2pStatus::UNABLE_TO_ACCOMMODATE_REQUEST));
138 translateMap.insert(
139 std::make_pair(P2pStatusCode::FAIL_PREVIOUS_PROTOCOL_ERROR, P2pStatus::PREVIOUS_PROTOCOL_ERROR));
140 translateMap.insert(std::make_pair(P2pStatusCode::FAIL_NO_COMMON_CHANNELS, P2pStatus::NO_COMMON_CHANNELS));
141 translateMap.insert(std::make_pair(P2pStatusCode::FAIL_UNKNOWN_P2P_GROUP, P2pStatus::UNKNOWN_P2P_GROUP));
142 translateMap.insert(std::make_pair(
143 P2pStatusCode::FAIL_BOTH_DEVICE_INDICATED_INTENT_15, P2pStatus::BOTH_DEVICE_INDICATED_INTENT_15));
144 translateMap.insert(std::make_pair(
145 P2pStatusCode::FAIL_INCOMPATIBLE_PROVISIONING_METHOD, P2pStatus::INCOMPATIBLE_PROVISIONING_METHOD));
146 translateMap.insert(std::make_pair(P2pStatusCode::FAIL_REJECTED_BY_USER, P2pStatus::REJECTED_BY_USER));
147
148 P2pStatus ret = P2pStatus::UNKNOWN;
149 auto iter = translateMap.find(static_cast<P2pStatusCode>(status));
150 if (iter == translateMap.end()) {
151 return ret;
152 }
153 ret = iter->second;
154 return ret;
155 }
156
Broadcast2SmConnectSupplicant(const std::string & iface,int status) const157 void P2pMonitor::Broadcast2SmConnectSupplicant(const std::string &iface, int status) const
158 {
159 std::any anyNone;
160 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::WPA_CONNECTED_EVENT, status, 0, anyNone);
161 }
162
Broadcast2SmDeviceFound(const std::string & iface,const WifiP2pDevice & device) const163 void P2pMonitor::Broadcast2SmDeviceFound(const std::string &iface, const WifiP2pDevice &device) const
164 {
165 std::any anyDevice = device;
166 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_DEVICE_FOUND, 0, 0, anyDevice);
167 }
168
Broadcast2SmPrivateDeviceFound(const std::string & iface,const std::string & privateInfo) const169 void P2pMonitor::Broadcast2SmPrivateDeviceFound(const std::string &iface, const std::string &privateInfo) const
170 {
171 std::any anyDevice = privateInfo;
172 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_PRI_DEVICE_FOUND, 0, 0, anyDevice);
173 }
174
Broadcast2SmDeviceLost(const std::string & iface,const WifiP2pDevice & device) const175 void P2pMonitor::Broadcast2SmDeviceLost(const std::string &iface, const WifiP2pDevice &device) const
176 {
177 std::any anyDevice = device;
178 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_DEVICE_LOST, 0, 0, anyDevice);
179 }
180
Broadcast2SmGoNegRequest(const std::string & iface,const WifiP2pConfigInternal & config) const181 void P2pMonitor::Broadcast2SmGoNegRequest(const std::string &iface, const WifiP2pConfigInternal &config) const
182 {
183 std::any anyConfig = config;
184 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_GO_NEG_REQUEST, 0, 0, anyConfig);
185 }
186
Broadcast2SmGoNegSuccess(const std::string & iface) const187 void P2pMonitor::Broadcast2SmGoNegSuccess(const std::string &iface) const
188 {
189 std::any anyNone;
190 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_GO_NEG_SUCCESS, 0, 0, anyNone);
191 }
192
Broadcast2SmGoNegFailure(const std::string & iface,P2pStatus p2pStatus) const193 void P2pMonitor::Broadcast2SmGoNegFailure(const std::string &iface, P2pStatus p2pStatus) const
194 {
195 std::any anyNone;
196 MessageToStateMachine(
197 iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_GO_NEG_FAILURE, static_cast<int>(p2pStatus), 0, anyNone);
198 }
199
Broadcast2SmInvitationReceived(const std::string & iface,const WifiP2pGroupInfo & group) const200 void P2pMonitor::Broadcast2SmInvitationReceived(const std::string &iface, const WifiP2pGroupInfo &group) const
201 {
202 std::any anyGroup = group;
203 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_INVITATION_RECEIVED, 0, 0, anyGroup);
204 }
205
Broadcast2SmInvitationResult(const std::string & iface,P2pStatus p2pStatus) const206 void P2pMonitor::Broadcast2SmInvitationResult(const std::string &iface, P2pStatus p2pStatus) const
207 {
208 std::any anyNone;
209 MessageToStateMachine(
210 iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_INVITATION_RESULT, static_cast<int>(p2pStatus), 0, anyNone);
211 }
212
Broadcast2SmGroupFormationSuccess(const std::string & iface) const213 void P2pMonitor::Broadcast2SmGroupFormationSuccess(const std::string &iface) const
214 {
215 std::any anyNone;
216 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_GROUP_FORMATION_SUCCESS, 0, 0, anyNone);
217 }
218
Broadcast2SmGroupFormationFailure(const std::string & iface,const std::string & reason) const219 void P2pMonitor::Broadcast2SmGroupFormationFailure(const std::string &iface, const std::string &reason) const
220 {
221 std::any anyReason = reason;
222 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_GROUP_FORMATION_FAILURE, 0, 0, anyReason);
223 }
224
Broadcast2SmGroupStarted(const std::string & iface,const WifiP2pGroupInfo & group) const225 void P2pMonitor::Broadcast2SmGroupStarted(const std::string &iface, const WifiP2pGroupInfo &group) const
226 {
227 std::any anyGroup = group;
228 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_GROUP_STARTED, 0, 0, anyGroup);
229 }
230
Broadcast2SmGroupRemoved(const std::string & iface,const WifiP2pGroupInfo & group) const231 void P2pMonitor::Broadcast2SmGroupRemoved(const std::string &iface, const WifiP2pGroupInfo &group) const
232 {
233 std::any anyGroup = group;
234 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_GROUP_REMOVED, 0, 0, anyGroup);
235 }
236
Broadcast2SmProvDiscPbcReq(const std::string & iface,const WifiP2pTempDiscEvent & event) const237 void P2pMonitor::Broadcast2SmProvDiscPbcReq(const std::string &iface, const WifiP2pTempDiscEvent &event) const
238 {
239 std::any anyEvent = event;
240 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_PBC_REQ, 0, 0, anyEvent);
241 }
242
Broadcast2SmProvDiscPbcResp(const std::string & iface,const WifiP2pTempDiscEvent & event) const243 void P2pMonitor::Broadcast2SmProvDiscPbcResp(const std::string &iface, const WifiP2pTempDiscEvent &event) const
244 {
245 std::any anyEvent = event;
246 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_PBC_RESP, 0, 0, anyEvent);
247 }
248
Broadcast2SmProvDiscEnterPin(const std::string & iface,const WifiP2pTempDiscEvent & event) const249 void P2pMonitor::Broadcast2SmProvDiscEnterPin(const std::string &iface, const WifiP2pTempDiscEvent &event) const
250 {
251 std::any anyEvent = event;
252 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_ENTER_PIN, 0, 0, anyEvent);
253 }
254
Broadcast2SmProvDiscShowPin(const std::string & iface,const WifiP2pTempDiscEvent & event) const255 void P2pMonitor::Broadcast2SmProvDiscShowPin(const std::string &iface, const WifiP2pTempDiscEvent &event) const
256 {
257 std::any anyEvent = event;
258 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_SHOW_PIN, 0, 0, anyEvent);
259 }
260
Broadcast2SmProvDiscFailure(const std::string & iface) const261 void P2pMonitor::Broadcast2SmProvDiscFailure(const std::string &iface) const
262 {
263 std::any anyNone;
264 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_PROV_DISC_FAILURE, 0, 0, anyNone);
265 }
266
Broadcast2SmFindStopped(const std::string & iface) const267 void P2pMonitor::Broadcast2SmFindStopped(const std::string &iface) const
268 {
269 std::any anyNone;
270 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_FIND_STOPPED, 0, 0, anyNone);
271 }
272
Broadcast2SmServDiscReq(const std::string & iface,const WifiP2pServiceRequestList & reqList) const273 void P2pMonitor::Broadcast2SmServDiscReq(const std::string &iface, const WifiP2pServiceRequestList &reqList) const
274 {
275 std::any anyReqList = reqList;
276 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_SERV_DISC_REQ, 0, 0, anyReqList);
277 }
278
Broadcast2SmServDiscResp(const std::string & iface,const WifiP2pServiceResponseList & respList) const279 void P2pMonitor::Broadcast2SmServDiscResp(const std::string &iface, const WifiP2pServiceResponseList &respList) const
280 {
281 std::any anyRespList = respList;
282 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_SERV_DISC_RESP, 0, 0, anyRespList);
283 }
284
Broadcast2SmApStaDisconnected(const std::string & iface,const WifiP2pDevice & device) const285 void P2pMonitor::Broadcast2SmApStaDisconnected(const std::string &iface, const WifiP2pDevice &device) const
286 {
287 std::any anyDevice = device;
288 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::AP_STA_DISCONNECTED, 0, 0, anyDevice);
289 }
290
Broadcast2SmApStaConnected(const std::string & iface,const WifiP2pDevice & device) const291 void P2pMonitor::Broadcast2SmApStaConnected(const std::string &iface, const WifiP2pDevice &device) const
292 {
293 std::any anyDevice = device;
294 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::AP_STA_CONNECTED, 0, 0, anyDevice);
295 }
296
Broadcast2SmConnectSupplicantFailed(const std::string & iface) const297 void P2pMonitor::Broadcast2SmConnectSupplicantFailed(const std::string &iface) const
298 {
299 std::any anyNone;
300 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::WPA_CONN_FAILED_EVENT, 0, 0, anyNone);
301 }
302
Broadcast2SmP2pIfaceCreated(const std::string & iface,int type,const std::string & event) const303 void P2pMonitor::Broadcast2SmP2pIfaceCreated(const std::string &iface, int type, const std::string &event) const
304 {
305 std::any anyEvent = event;
306 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_IFACE_CREATED, type, 0, anyEvent);
307 }
308
Broadcast2SmConnectFailed(const std::string & iface,int reason,const WifiP2pDevice & device) const309 void P2pMonitor::Broadcast2SmConnectFailed(const std::string &iface, int reason, const WifiP2pDevice &device) const
310 {
311 std::any anyDevice = device;
312 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_CONNECT_FAILED, reason, 0, anyDevice);
313 }
314
OnConnectSupplicant(int status) const315 void P2pMonitor::OnConnectSupplicant(int status) const
316 {
317 WIFI_LOGD("OnConnectSupplicant callback");
318 Broadcast2SmConnectSupplicant(selectIfacName, status);
319 }
320
Broadcast2SmChSwitch(const std::string & iface,const WifiP2pGroupInfo & group) const321 void P2pMonitor::Broadcast2SmChSwitch(const std::string &iface, const WifiP2pGroupInfo &group) const
322 {
323 std::any anyGroup = group;
324 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_CH_SWITCH, 0, 0, anyGroup);
325 }
326
Broadcast2SmChrEvent(const std::string & iface,const int & errCode) const327 void P2pMonitor::Broadcast2SmChrEvent(const std::string &iface, const int &errCode) const
328 {
329 std::any anyNone;
330 MessageToStateMachine(iface, P2P_STATE_MACHINE_CMD::P2P_EVENT_CHR_REPORT, errCode, 0, anyNone);
331 }
332
WpaEventDeviceFound(const HalP2pDeviceFound & deviceInfo) const333 void P2pMonitor::WpaEventDeviceFound(const HalP2pDeviceFound &deviceInfo) const
334 {
335 const int minWfdLength = 6;
336 WIFI_LOGI("onDeviceFound callback");
337 WifiP2pDevice device;
338 device.SetDeviceName(deviceInfo.deviceName);
339 if (device.GetDeviceName().empty()) {
340 WIFI_LOGE("Missing device name!");
341 return;
342 }
343 device.SetDeviceAddress(deviceInfo.p2pDeviceAddress);
344 device.SetPrimaryDeviceType(deviceInfo.primaryDeviceType);
345 device.SetDeviceCapabilitys(deviceInfo.deviceCapabilities);
346 device.SetGroupCapabilitys(deviceInfo.groupCapabilities);
347 device.SetWpsConfigMethod(deviceInfo.configMethods);
348 device.SetP2pDeviceStatus(P2pDeviceStatus::PDS_AVAILABLE);
349 const int wfdInfoTwo = 2;
350 const int wfdInfoThree = 3;
351 const int wfdInfoFour = 4;
352 const int wfdInfoFive = 5;
353 if (deviceInfo.wfdDeviceInfo.size() >= minWfdLength) {
354 WifiP2pWfdInfo wfdInfo(
355 ((deviceInfo.wfdDeviceInfo[0] & 0xFF) << CHAR_BIT) + (deviceInfo.wfdDeviceInfo[1] & 0xFF),
356 ((deviceInfo.wfdDeviceInfo[wfdInfoTwo] & 0xFF) << CHAR_BIT) +
357 (deviceInfo.wfdDeviceInfo[wfdInfoThree] & 0xFF),
358 ((deviceInfo.wfdDeviceInfo[wfdInfoFour] & 0xFF) << CHAR_BIT) +
359 (deviceInfo.wfdDeviceInfo[wfdInfoFive] & 0xFF));
360 device.SetWfdInfo(wfdInfo);
361 }
362 if (deviceInfo.wfdDeviceInfo.size() > minWfdLength) {
363 std::string p2pDeviceAddress = deviceInfo.p2pDeviceAddress;
364 std::string wfdDeviceInfo(reinterpret_cast<const char*>(deviceInfo.wfdDeviceInfo.data()),
365 deviceInfo.wfdDeviceInfo.size());
366 std::string privateInfo = p2pDeviceAddress + wfdDeviceInfo;
367 Broadcast2SmPrivateDeviceFound(selectIfacName, privateInfo);
368 }
369 Broadcast2SmDeviceFound(selectIfacName, device);
370 }
371
WpaEventDeviceLost(const std::string & p2pDeviceAddress) const372 void P2pMonitor::WpaEventDeviceLost(const std::string &p2pDeviceAddress) const
373 {
374 WIFI_LOGI("onDeviceLost callback, p2pDeviceAddress:%{private}s", p2pDeviceAddress.c_str());
375 WifiP2pDevice device;
376 device.SetDeviceAddress(p2pDeviceAddress);
377 if (device.GetDeviceAddress().empty()) {
378 WIFI_LOGE("ERROR!");
379 return;
380 }
381 device.SetP2pDeviceStatus(P2pDeviceStatus::PDS_UNAVAILABLE);
382
383 Broadcast2SmDeviceLost(selectIfacName, device);
384 }
385
WpaEventGoNegRequest(const std::string & srcAddress,short passwordId) const386 void P2pMonitor::WpaEventGoNegRequest(const std::string &srcAddress, short passwordId) const
387 {
388 WIFI_LOGI("WpaEventGoNegRequest srcAddress:%{private}s, passwordId:%{private}hd", srcAddress.c_str(), passwordId);
389 WifiP2pConfigInternal config;
390 config.SetDeviceAddress(srcAddress);
391 if (config.GetDeviceAddress().empty()) {
392 WIFI_LOGE("ERROR!");
393 return;
394 }
395
396 WpsInfo wps;
397 switch (static_cast<WpsDevPasswordId>(passwordId)) {
398 case WpsDevPasswordId::USER_SPECIFIED: {
399 wps.SetWpsMethod(WpsMethod::WPS_METHOD_DISPLAY);
400 break;
401 }
402 case WpsDevPasswordId::PUSHBUTTON: {
403 wps.SetWpsMethod(WpsMethod::WPS_METHOD_PBC);
404 break;
405 }
406 case WpsDevPasswordId::REGISTRAR_SPECIFIED: {
407 wps.SetWpsMethod(WpsMethod::WPS_METHOD_KEYPAD);
408 break;
409 }
410 default:
411 wps.SetWpsMethod(WpsMethod::WPS_METHOD_PBC);
412 break;
413 }
414 config.SetWpsInfo(wps);
415
416 Broadcast2SmGoNegRequest(selectIfacName, config);
417 }
418
WpaEventGoNegSuccess(void) const419 void P2pMonitor::WpaEventGoNegSuccess(void) const
420 {
421 WIFI_LOGI("onGoNegotiationSuccess callback");
422 Broadcast2SmGoNegSuccess(selectIfacName);
423 }
424
WpaEventGoNegFailure(int status) const425 void P2pMonitor::WpaEventGoNegFailure(int status) const
426 {
427 WIFI_LOGI("onGoNegotiationFailure callback status:%{public}d", status);
428 P2pStatus p2pStatus = IntStatusToP2pStatus(status);
429 WriteP2pAbDisConnectHiSysEvent(static_cast<int>(P2P_ERROR_CODE::NEGO_FAILURE_ERROR),
430 static_cast<int>(P2P_ERROR_RES::NEGO_FAILURE));
431 Broadcast2SmGoNegFailure(selectIfacName, p2pStatus);
432 }
433
WpaEventInvitationReceived(const HalP2pInvitationInfo & recvInfo) const434 void P2pMonitor::WpaEventInvitationReceived(const HalP2pInvitationInfo &recvInfo) const
435 {
436 WIFI_LOGI("onInvitationReceived callback");
437 WifiP2pGroupInfo group;
438 group.SetNetworkId(recvInfo.persistentNetworkId);
439
440 WifiP2pDevice device;
441 device.SetDeviceAddress(recvInfo.srcAddress);
442 if (device.GetDeviceAddress().empty()) {
443 WIFI_LOGE("ERROR! device mac empty!");
444 return;
445 }
446 group.AddClientDevice(device);
447
448 WifiP2pDevice owner;
449 if (recvInfo.goDeviceAddress.empty()) {
450 owner.SetDeviceAddress(recvInfo.srcAddress);
451 } else {
452 owner.SetDeviceAddress(recvInfo.goDeviceAddress);
453 }
454 WIFI_LOGD("owner mac: %{private}s, persistentNetworkId:%{public}d.",
455 owner.GetDeviceAddress().c_str(), recvInfo.persistentNetworkId);
456 /**
457 * If owner addr is empty, a NET ID is required, indicating a persistent group invitation.
458 * After receiving the message, the state machine determines the case.
459 */
460 if (owner.GetDeviceAddress().empty()) {
461 WIFI_LOGW("owner mac empty! wpa persistent_reconnect and skip invition msg.");
462 return;
463 }
464 group.SetOwner(owner);
465
466 Broadcast2SmInvitationReceived(selectIfacName, group);
467 }
468
WpaEventInvitationResult(const std::string & bssid,int status) const469 void P2pMonitor::WpaEventInvitationResult(const std::string &bssid, int status) const
470 {
471 WIFI_LOGI("onInvitationResult callback, bssid:%{public}s, status:%{public}d",
472 MacAnonymize(bssid).c_str(), status);
473 P2pStatus p2pStatus = IntStatusToP2pStatus(status);
474 Broadcast2SmInvitationResult(selectIfacName, p2pStatus);
475 }
476
WpaEventGroupFormationSuccess(void) const477 void P2pMonitor::WpaEventGroupFormationSuccess(void) const
478 {
479 WIFI_LOGD("onGroupFormationSuccess callback");
480 Broadcast2SmGroupFormationSuccess(selectIfacName);
481 }
482
WpaEventGroupFormationFailure(const std::string & failureReason) const483 void P2pMonitor::WpaEventGroupFormationFailure(const std::string &failureReason) const
484 {
485 WIFI_LOGD("onGroupFormationFailure callback, failureReason:%{public}s", failureReason.c_str());
486 std::string reason(failureReason);
487 WriteP2pConnectFailedHiSysEvent(static_cast<int>(P2P_ERROR_CODE::FORMATION_ERROR),
488 static_cast<int>(P2P_ERROR_RES::FORMATION_FAILURE));
489 Broadcast2SmGroupFormationFailure(selectIfacName, reason);
490 }
491
WpaEventGroupStarted(const HalP2pGroupInfo & groupInfo) const492 void P2pMonitor::WpaEventGroupStarted(const HalP2pGroupInfo &groupInfo) const
493 {
494 WIFI_LOGD("onGroupStarted callback");
495 if (groupInfo.groupName.empty()) {
496 WIFI_LOGE("Missing group interface name.");
497 return;
498 }
499
500 WifiP2pGroupInfo group;
501 group.SetInterface(groupInfo.groupName);
502 group.SetGroupName(groupInfo.ssid);
503 group.SetFrequency(groupInfo.frequency);
504 group.SetIsGroupOwner(groupInfo.isGo);
505 if (groupInfo.isGo) {
506 group.SetPassphrase(groupInfo.passphrase);
507 } else {
508 group.SetPassphrase(std::string(groupInfo.psk));
509 }
510 if (groupInfo.isPersistent && groupInfo.psk.empty()) {
511 WIFI_LOGE("groupinfo isPersistent and psk is null");
512 group.SetIsPersistent(0);
513 } else {
514 group.SetIsPersistent(groupInfo.isPersistent);
515 }
516 WifiP2pDevice owner;
517 owner.SetDeviceAddress(groupInfo.goDeviceAddress);
518 owner.SetRandomDeviceAddress(groupInfo.goRandomAddress);
519
520 group.SetOwner(owner);
521 Broadcast2SmGroupStarted(selectIfacName, group);
522 }
523
WpaEventGroupRemoved(const std::string & groupIfName,bool isGo) const524 void P2pMonitor::WpaEventGroupRemoved(const std::string &groupIfName, bool isGo) const
525 {
526 WIFI_LOGD("onGroupRemoved callback, groupIfName:%{private}s, isGo:%{public}s", groupIfName.c_str(),
527 (isGo) ? "true" : "false");
528 if (groupIfName.empty()) {
529 WIFI_LOGE("ERROR! No group name!");
530 return;
531 }
532 WifiP2pGroupInfo group;
533 group.SetInterface(groupIfName);
534 group.SetIsGroupOwner(isGo);
535 Broadcast2SmGroupRemoved(selectIfacName, group);
536 }
537
WpaEventProvDiscPbcReq(const std::string & p2pDeviceAddress) const538 void P2pMonitor::WpaEventProvDiscPbcReq(const std::string &p2pDeviceAddress) const
539 {
540 WIFI_LOGD("onProvisionDiscoveryPbcRequest callback, p2pDeviceAddress:%{private}s", p2pDeviceAddress.c_str());
541 WifiP2pTempDiscEvent event;
542 WifiP2pDevice tempDevice;
543 tempDevice.SetDeviceAddress(p2pDeviceAddress);
544 event.SetDevice(tempDevice);
545 event.SetDiscEvent(DiscEvent::PBC_REQ);
546 Broadcast2SmProvDiscPbcReq(selectIfacName, event);
547 }
548
WpaEventProvDiscPbcResp(const std::string & p2pDeviceAddress) const549 void P2pMonitor::WpaEventProvDiscPbcResp(const std::string &p2pDeviceAddress) const
550 {
551 WIFI_LOGD("onProvisionDiscoveryPbcResponse callback, p2pDeviceAddress:%{private}s", p2pDeviceAddress.c_str());
552 WifiP2pTempDiscEvent event;
553 WifiP2pDevice tempDevice;
554 tempDevice.SetDeviceAddress(p2pDeviceAddress);
555 event.SetDevice(tempDevice);
556 event.SetDiscEvent(DiscEvent::PBC_RESP);
557 Broadcast2SmProvDiscPbcResp(selectIfacName, event);
558 }
559
WpaEventProvDiscEnterPin(const std::string & p2pDeviceAddress) const560 void P2pMonitor::WpaEventProvDiscEnterPin(const std::string &p2pDeviceAddress) const
561 {
562 WIFI_LOGD("onProvisionDiscoveryEnterPin callback, p2pDeviceAddress:%{private}s", p2pDeviceAddress.c_str());
563 WifiP2pTempDiscEvent event;
564 WifiP2pDevice tempDevice;
565 tempDevice.SetDeviceAddress(p2pDeviceAddress);
566 event.SetDevice(tempDevice);
567 event.SetDiscEvent(DiscEvent::ENTER_PIN);
568 Broadcast2SmProvDiscEnterPin(selectIfacName, event);
569 }
570
WpaEventProvDiscShowPin(const std::string & p2pDeviceAddress,const std::string & generatedPin) const571 void P2pMonitor::WpaEventProvDiscShowPin(const std::string &p2pDeviceAddress, const std::string &generatedPin) const
572 {
573 WIFI_LOGD("onProvisionDiscoveryShowPin callback, p2pDeviceAddress:%{private}s, generatedPin:%{private}s",
574 p2pDeviceAddress.c_str(),
575 generatedPin.c_str());
576 WifiP2pTempDiscEvent event;
577 WifiP2pDevice tempDevice;
578 tempDevice.SetDeviceAddress(p2pDeviceAddress);
579 event.SetDevice(tempDevice);
580 event.SetDiscEvent(DiscEvent::SHOW_PIN);
581 event.SetPin(generatedPin);
582 Broadcast2SmProvDiscShowPin(selectIfacName, event);
583 }
584
WpaEventProvDiscFailure(void) const585 void P2pMonitor::WpaEventProvDiscFailure(void) const
586 {
587 WIFI_LOGD("onProvisionDiscoveryFailure callback");
588 WriteP2pConnectFailedHiSysEvent(static_cast<int>(P2P_ERROR_CODE::P2P_DISCOVER_FAILURE_ERROR),
589 static_cast<int>(P2P_ERROR_RES::P2P_DISCOVERY_FAILURE));
590 Broadcast2SmProvDiscFailure(selectIfacName);
591 }
592
WpaEventFindStopped(void) const593 void P2pMonitor::WpaEventFindStopped(void) const
594 {
595 WIFI_LOGD("onFindStopped callback");
596 Broadcast2SmFindStopped(selectIfacName);
597 }
598
WpaEventServDiscReq(const HalP2pServDiscReqInfo & reqInfo) const599 void P2pMonitor::WpaEventServDiscReq(const HalP2pServDiscReqInfo &reqInfo) const
600 {
601 WIFI_LOGD("OnServDiscReq callback");
602 WifiP2pServiceRequestList reqList;
603 reqList.SetUpdateIndic(reqInfo.updateIndic);
604 reqList.SetFrequency(reqInfo.freq);
605 reqList.SetDialogToken(reqInfo.dialogToken);
606 WifiP2pDevice device;
607 device.SetDeviceAddress(reqInfo.mac);
608 reqList.SetDevice(device);
609 reqList.ParseTlvs2ReqList(reqInfo.tlvList);
610 Broadcast2SmServDiscReq(selectIfacName, reqList);
611 }
612
WpaEventServDiscResp(const std::string & srcAddress,short updateIndicator,const std::vector<unsigned char> & tlvList) const613 void P2pMonitor::WpaEventServDiscResp(
614 const std::string &srcAddress, short updateIndicator, const std::vector<unsigned char> &tlvList) const
615 {
616 WIFI_LOGD("onServiceDiscoveryResponse callback");
617 WifiP2pServiceResponseList respList;
618 WifiP2pDevice device;
619 device.SetDeviceAddress(srcAddress);
620 respList.SetDevice(device);
621 respList.SetUpdateIndic(updateIndicator);
622 respList.ParseTlvs2RespList(tlvList);
623 Broadcast2SmServDiscResp(selectIfacName, respList);
624 }
625
WpaEventApStaDisconnected(const std::string & p2pDeviceAddress) const626 void P2pMonitor::WpaEventApStaDisconnected(const std::string &p2pDeviceAddress) const
627 {
628 WIFI_LOGD("onStaDeauthorized callback, p2pDeviceAddress:%{private}s", p2pDeviceAddress.c_str());
629 WifiP2pDevice device;
630 device.SetDeviceAddress(p2pDeviceAddress);
631 Broadcast2SmApStaDisconnected(selectIfacName, device);
632 }
633
WpaEventApStaConnected(const std::string & p2pDeviceAddress,const std::string & p2pGroupAddress) const634 void P2pMonitor::WpaEventApStaConnected(const std::string &p2pDeviceAddress,
635 const std::string &p2pGroupAddress) const
636 {
637 WIFI_LOGD("onStaAuthorized callback, p2pDeviceAddress:%{private}s p2pGroupAddress %{private}s",
638 p2pDeviceAddress.c_str(), p2pGroupAddress.c_str());
639 WifiP2pDevice device;
640 device.SetDeviceAddress(p2pDeviceAddress);
641 device.SetGroupAddress(p2pGroupAddress);
642 device.SetRandomDeviceAddress(p2pGroupAddress);
643 Broadcast2SmApStaConnected(selectIfacName, device);
644 }
645
OnConnectSupplicantFailed(void) const646 void P2pMonitor::OnConnectSupplicantFailed(void) const
647 {
648 WIFI_LOGD("OnConnectSupplicantFailed callback");
649 Broadcast2SmConnectSupplicantFailed(selectIfacName);
650 }
651
WpaEventP2pIfaceCreated(const std::string & ifName,int isGo) const652 void P2pMonitor::WpaEventP2pIfaceCreated(const std::string &ifName, int isGo) const
653 {
654 WIFI_LOGI("onP2pIfaceCreated callback, ifname:%{private}s, isGo:%{public}s", ifName.c_str(),
655 (isGo == 0) ? "false" : "true");
656 if (ifName.empty()) {
657 WIFI_LOGE("ERROR! No ifname!");
658 return;
659 }
660 Broadcast2SmP2pIfaceCreated(selectIfacName, isGo, ifName);
661 }
662
WpaEventP2pConnectFailed(const std::string & bssid,int reason) const663 void P2pMonitor::WpaEventP2pConnectFailed(const std::string &bssid, int reason) const
664 {
665 WIFI_LOGD("WpaEventP2pConnectFailed callback, bssid:%{public}s, reason:%{public}d",
666 MacAnonymize(bssid).c_str(), reason);
667 WifiP2pDevice device;
668 device.SetDeviceAddress(bssid);
669 Broadcast2SmConnectFailed(selectIfacName, reason, device);
670 }
671
WpaEventP2pChannelSwitch(int freq) const672 void P2pMonitor::WpaEventP2pChannelSwitch(int freq) const
673 {
674 WIFI_LOGI("WpaEventP2pChannelSwitch callback, freq:%{public}d", freq);
675 WifiP2pGroupInfo group;
676 group.SetFrequency(freq);
677 Broadcast2SmChSwitch(selectIfacName, group);
678 }
679
WpaEventP2pChrReport(int errCode) const680 void P2pMonitor::WpaEventP2pChrReport(int errCode) const
681 {
682 WIFI_LOGI("WpaEventP2pChrReport callback, errCode:%{public}d", errCode);
683 Broadcast2SmChrEvent(selectIfacName, errCode);
684 }
685
WpaEventStaNotifyCallBack(const std::string & notifyParam) const686 void P2pMonitor::WpaEventStaNotifyCallBack(const std::string ¬ifyParam) const
687 {
688 WIFI_LOGI("WpaEventStaNotifyCallBack callback, notifyParam:%{private}s", notifyParam.c_str());
689 if (notifyParam.empty()) {
690 WIFI_LOGE("WpaEventStaNotifyCallBack() notifyParam is empty");
691 return;
692 }
693 std::string::size_type begPos = 0;
694 if ((begPos = notifyParam.find(":")) == std::string::npos) {
695 WIFI_LOGI("WpaEventStaNotifyCallBack() notifyParam not find :");
696 return;
697 }
698 std::string type = notifyParam.substr(0, begPos);
699 int num = CheckDataLegal(type);
700 switch (num) {
701 case static_cast<int>(WpaEventCallback::CSA_CHSWITCH_NUM): {
702 std::string::size_type freqPos = 0;
703 if ((freqPos = notifyParam.find("freq=")) == std::string::npos) {
704 WIFI_LOGE("csa channel switch notifyParam not find frequency!");
705 return;
706 }
707 std::string data = notifyParam.substr(freqPos + strlen("freq="));
708 int freq = CheckDataLegal(data);
709 WpaEventP2pChannelSwitch(freq);
710 break;
711 }
712 case static_cast<int>(WpaEventCallback::CHR_EVENT_NUM): {
713 std::string::size_type codePos = 0;
714 if ((codePos = notifyParam.find("errCode=")) == std::string::npos) {
715 WIFI_LOGE("chr event notifyParam not find errCode!");
716 return;
717 }
718 std::string data = notifyParam.substr(codePos + strlen("errCode="));
719 int errCode = CheckDataLegal(data);
720 WpaEventP2pChrReport(errCode);
721 break;
722 }
723 default:
724 WIFI_LOGI("WpaEventStaNotifyCallBack() undefine event:%{public}d", num);
725 break;
726 }
727 }
728 } // namespace Wifi
729 } // namespace OHOS
730