1 /*
2  * Copyright (c) 2023 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 #ifdef HDI_WPA_INTERFACE_SUPPORT
17 #include "wifi_hdi_wpa_callback.h"
18 #include "wifi_sta_hal_interface.h"
19 #include "wifi_supplicant_hal_interface.h"
20 #include "wifi_hdi_util.h"
21 #include "wifi_ap_hal_interface.h"
22 #include "wifi_p2p_hal_interface.h"
23 #include "wifi_hdi_common.h"
24 #include "wifi_common_util.h"
25 #include "wifi_native_define.h"
26 #include "wifi_msg.h"
27 #include "wifi_config_center.h"
28 #include "wifi_log.h"
29 #ifdef UT_TEST
30 #define static
31 #endif
32 
33 constexpr int WIFI_HDI_STR_MAC_LENGTH = 17;
34 constexpr int WIFI_HDI_REASON_LENGTH = 32;
35 constexpr int PD_STATUS_CODE_SHOW_PIN = 0;
36 constexpr int PD_STATUS_CODE_ENTER_PIN = 1;
37 constexpr int PD_STATUS_CODE_PBC_REQ = 2;
38 constexpr int PD_STATUS_CODE_PBC_RSP = 3;
39 constexpr int PD_STATUS_CODE_FAIL = 4;
40 constexpr int WEP_WRONG_PASSWORD_STATUS_CODE = 5202;
41 int g_currentWpaStatus = static_cast<int>(OHOS::Wifi::SupplicantState::UNKNOWN);
42 #undef LOG_TAG
43 #define LOG_TAG "WifiHdiWpaCallback"
44 
OnEventDisconnected(struct IWpaCallback * self,const struct HdiWpaDisconnectParam * disconectParam,const char * ifName)45 int32_t OnEventDisconnected(struct IWpaCallback *self,
46     const struct HdiWpaDisconnectParam *disconectParam, const char* ifName)
47 {
48     if (ifName == nullptr) {
49         LOGE("OnEventDisconnected: invalid ifName!");
50         return 1;
51     }
52     LOGI("OnEventDisconnected: callback enter! ifName = %{public}s", ifName);
53     if (disconectParam == NULL || disconectParam->bssidLen <= 0) {
54         LOGE("OnEventDisconnected: invalid parameter!");
55         return 1;
56     }
57     uint32_t bssidLen = disconectParam->bssidLen;
58     char szBssid[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
59     if (ConvertMacArr2String(disconectParam->bssid, bssidLen, szBssid, sizeof(szBssid)) != 0) {
60         LOGE("%{public}s: failed to convert mac!", __func__);
61         return 1;
62     }
63     int reasonCode = disconectParam->reasonCode;
64     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
65     if (cbk.onReportDisConnectReason) {
66         cbk.onReportDisConnectReason(reasonCode, std::string(szBssid));
67     }
68     bool isPsk = false;
69     std::vector<OHOS::Wifi::WifiScanInfo> scanResults;
70     OHOS::Wifi::WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(scanResults);
71     for (OHOS::Wifi::WifiScanInfo &item : scanResults) {
72         if (strcasecmp(item.bssid.c_str(), szBssid) == 0 &&
73             (item.capabilities.find("PSK") != std::string::npos ||
74             item.capabilities.find("WAPI-PSK") != std::string::npos)) {
75                 isPsk = true;
76                 break;
77         }
78     }
79     int locallyGenerated = disconectParam->locallyGenerated;
80     if (cbk.onWpaSsidWrongKey && isPsk &&
81         g_currentWpaStatus == static_cast<int>(OHOS::Wifi::SupplicantState::FOUR_WAY_HANDSHAKE) &&
82         (reasonCode != Wifi80211ReasonCode::WLAN_REASON_IE_IN_4WAY_DIFFERS || !locallyGenerated)) {
83         LOGI("OnEventDisconnected, wrong password");
84         cbk.onWpaSsidWrongKey();
85     }
86     if (cbk.onConnectChanged) {
87         cbk.onConnectChanged(HAL_WPA_CB_DISCONNECTED, reasonCode, std::string(szBssid));
88     }
89     LOGI("%{public}s callback out, bssid:%{public}s ifName = %{public}s",
90         __func__,
91         OHOS::Wifi::MacAnonymize(szBssid).c_str(),
92         ifName);
93     return 0;
94 }
95 
OnEventConnected(struct IWpaCallback * self,const struct HdiWpaConnectParam * connectParam,const char * ifName)96 int32_t OnEventConnected(struct IWpaCallback *self,
97     const struct HdiWpaConnectParam *connectParam, const char* ifName)
98 {
99     if (ifName == nullptr) {
100         LOGE("OnEventConnected: invalid ifName!");
101         return 1;
102     }
103     LOGI("OnEventConnected: callback enter! ifName = %{public}s", ifName);
104     if (connectParam == NULL || connectParam->bssidLen <= 0) {
105         LOGE("OnEventConnected: invalid parameter!");
106         return 1;
107     }
108     uint32_t bssidLen = connectParam->bssidLen;
109     char szBssid[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
110     if (ConvertMacArr2String(connectParam->bssid, bssidLen, szBssid, sizeof(szBssid)) != 0) {
111         LOGE("%{public}s: failed to convert mac!", __func__);
112         return 1;
113     }
114     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
115     if (cbk.onConnectChanged) {
116         cbk.onConnectChanged(HAL_WPA_CB_CONNECTED, connectParam->networkId, szBssid);
117     }
118     LOGI("%{public}s callback out ,bssid = %{public}s", __func__, OHOS::Wifi::MacAnonymize(szBssid).c_str());
119     return 0;
120 }
121 
OnEventBssidChanged(struct IWpaCallback * self,const struct HdiWpaBssidChangedParam * bssidChangedParam,const char * ifName)122 int32_t OnEventBssidChanged(struct IWpaCallback *self,
123     const struct HdiWpaBssidChangedParam *bssidChangedParam, const char* ifName)
124 {
125     if (ifName == nullptr) {
126         LOGE("OnEventBssidChanged: invalid ifName!");
127         return 1;
128     }
129     LOGI("OnEventBssidChanged: callback enter! ifName = %{public}s", ifName);
130     if (bssidChangedParam == nullptr || bssidChangedParam->reason == nullptr) {
131         LOGE("OnEventBssidChanged: invalid parameter!");
132         return 1;
133     }
134 
135     std::string reason = "";
136     if (bssidChangedParam->reasonLen > 0 && bssidChangedParam->reasonLen < WIFI_HDI_REASON_LENGTH) {
137         reason = std::string(bssidChangedParam->reason, bssidChangedParam->reason + bssidChangedParam->reasonLen);
138     } else {
139         LOGE("OnEventBssidChanged: invalid reasonLen:%{public}u", bssidChangedParam->reasonLen);
140     }
141     char szBssid[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
142     if (ConvertMacArr2String(bssidChangedParam->bssid, bssidChangedParam->bssidLen, szBssid, sizeof(szBssid)) != 0) {
143         LOGE("OnEventBssidChanged: failed to convert mac!");
144         return 1;
145     }
146 
147     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
148     if (cbk.onBssidChanged) {
149         cbk.onBssidChanged(reason, szBssid);
150     }
151     LOGI("%{public}s callback out, bssid:%{public}s reason:%{public}s reasonLen:%{public}u",
152         __func__, OHOS::Wifi::MacAnonymize(szBssid).c_str(), reason.c_str(), bssidChangedParam->reasonLen);
153     return 0;
154 }
155 
OnEventStateChanged(struct IWpaCallback * self,const struct HdiWpaStateChangedParam * statechangedParam,const char * ifName)156 int32_t OnEventStateChanged(struct IWpaCallback *self,
157     const struct HdiWpaStateChangedParam *statechangedParam, const char* ifName)
158 {
159     if (ifName == nullptr) {
160         LOGE("OnEventStateChanged: invalid ifName!");
161         return 1;
162     }
163     LOGI("OnEventStateChanged: callback enter! ifName = %{public}s", ifName);
164     if (statechangedParam == NULL) {
165         LOGE("OnEventStateChanged: invalid parameter!");
166         return 1;
167     }
168 
169     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
170     g_currentWpaStatus = statechangedParam->status;
171     if (cbk.onWpaStateChanged) {
172         cbk.onWpaStateChanged(g_currentWpaStatus);
173     }
174     LOGI("OnEventStateChanged:callback out status = %{public}d, ifName = %{public}s", g_currentWpaStatus, ifName);
175     return 0;
176 }
177 
OnEventTempDisabled(struct IWpaCallback * self,const struct HdiWpaTempDisabledParam * tempDisabledParam,const char * ifName)178 int32_t OnEventTempDisabled(struct IWpaCallback *self,
179     const struct HdiWpaTempDisabledParam *tempDisabledParam, const char *ifName)
180 {
181     if (ifName == nullptr) {
182         LOGE("OnEventTempDisabled: invalid ifName!");
183         return 1;
184     }
185     LOGI("OnEventTempDisabled: callback enter! ifName = %{public}s", ifName);
186 
187     if (tempDisabledParam == NULL) {
188         LOGE("OnEventTempDisabled tempDisabledParam is NULL");
189         return 1;
190     }
191     std::string ssid = "";
192     if (tempDisabledParam->ssid != NULL && tempDisabledParam->ssidLen > 0) {
193         ssid = std::string(tempDisabledParam->ssid, tempDisabledParam->ssid + tempDisabledParam->ssidLen);
194     }
195     std::string reason = "";
196     if (tempDisabledParam->reason != NULL && tempDisabledParam->reasonLen > 0) {
197         reason = std::string(tempDisabledParam->reason, tempDisabledParam->reason + tempDisabledParam->reasonLen);
198     }
199     LOGI("OnEventTempDisabled ssid:%{public}s reason:%{public}s, ifName = %{public}s",
200         OHOS::Wifi::SsidAnonymize(ssid).c_str(),
201         reason.c_str(),
202         ifName);
203     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
204     if (cbk.onWpaSsidWrongKey && reason == "AUTH_FAILED") {
205         cbk.onWpaSsidWrongKey();
206     }
207     return 0;
208 }
209 
OnEventAssociateReject(struct IWpaCallback * self,const struct HdiWpaAssociateRejectParam * associateRejectParam,const char * ifName)210 int32_t OnEventAssociateReject(struct IWpaCallback *self,
211     const struct HdiWpaAssociateRejectParam *associateRejectParam, const char *ifName)
212 {
213     if (ifName == nullptr) {
214         LOGE("OnEventAssociateReject: invalid ifName!");
215         return 1;
216     }
217     LOGI("OnEventAssociateReject: callback enter! ifName = %{public}s", ifName);
218     if (associateRejectParam == NULL) {
219         LOGE("OnEventAssociateReject: invalid parameter!");
220         return 1;
221     }
222     char bssid[WIFI_HDI_STR_MAC_LENGTH + 1] = {0};
223     ConvertMacArr2String(associateRejectParam->bssid, associateRejectParam->bssidLen, bssid, sizeof(bssid));
224     int statusCode = associateRejectParam->statusCode;
225 
226     /* Special handling for WPA3-Personal networks. If the password is
227        incorrect, the AP will send association rejection, with status code 1
228        (unspecified failure). In SAE networks, the password authentication
229        is not related to the 4-way handshake. In this case, we will send an
230        authentication failure event up. */
231     bool isWrongPwd = false;
232     std::vector<OHOS::Wifi::WifiScanInfo> scanResults;
233     OHOS::Wifi::WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(scanResults);
234     for (OHOS::Wifi::WifiScanInfo &item : scanResults) {
235         if (strcasecmp(item.bssid.c_str(), bssid) == 0) {
236             if (statusCode == Wifi80211StatusCode::WLAN_STATUS_UNSPECIFIED_FAILURE &&
237                 (item.capabilities.find("SAE") != std::string::npos)) {
238                 isWrongPwd = true;
239                 break;
240             } else if (statusCode == WEP_WRONG_PASSWORD_STATUS_CODE &&
241                 item.capabilities.find("WEP") != std::string::npos) {
242                 isWrongPwd = true;
243                 break;
244             }
245         }
246     }
247     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
248     if (isWrongPwd && cbk.onWpaSsidWrongKey) {
249         LOGI("onWpaConnectionRejectCallBack, wrong password");
250         cbk.onWpaSsidWrongKey();
251         return 0;
252     }
253     if ((statusCode == Wifi80211StatusCode::WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA ||
254         statusCode == Wifi80211StatusCode::WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY ||
255         statusCode == Wifi80211StatusCode::WLAN_STATUS_DENIED_INSUFFICIENT_BANDWIDTH) &&
256         cbk.onWpaConnectionFull) {
257         LOGI("onWpaConnectionRejectCallBack, connect full");
258         cbk.onWpaConnectionFull(statusCode);
259         return 0;
260     }
261     if (cbk.onWpaConnectionReject) {
262         LOGI("onWpaConnectionRejectCallBack");
263         cbk.onWpaConnectionReject(statusCode);
264     }
265     return 0;
266 }
267 
OnEventStaNotify(struct IWpaCallback * self,const char * notifyParam,const char * ifName)268 int32_t OnEventStaNotify(struct IWpaCallback *self, const char* notifyParam, const char *ifName)
269 {
270     if (ifName == nullptr) {
271         LOGE("OnEventStaNotify: invalid ifName!");
272         return 1;
273     }
274     LOGI("OnEventStaNotify: callback enter! ifName = %{public}s", ifName);
275     if (notifyParam == NULL) {
276         LOGE("OnEventStaNotify: invalid parameter!");
277         return 1;
278     }
279 
280     if (strcmp(ifName, "wlan0") == 0 || strcmp(ifName, "wlan1") == 0) {
281         const OHOS::Wifi::WifiEventCallback &cbk =
282             OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
283         if (cbk.onEventStaNotify) {
284             cbk.onEventStaNotify(notifyParam);
285         }
286     } else if (strncmp(ifName, "p2p", strlen("p2p")) == 0) {
287         const OHOS::Wifi::P2pHalCallback &p2pCbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
288         if (p2pCbk.onEventStaNotify) {
289             p2pCbk.onEventStaNotify(notifyParam);
290         }
291     }
292     return 0;
293 }
294 
OnEventWpsOverlap(struct IWpaCallback * self,const char * ifName)295 int32_t OnEventWpsOverlap(struct IWpaCallback *self, const char *ifName)
296 {
297     if (ifName == nullptr) {
298         LOGE("OnEventWpsOverlap: invalid ifName!");
299         return 1;
300     }
301     LOGI("OnEventWpsOverlap: callback enter! ifName = %{public}s", ifName);
302     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
303     if (cbk.onWpsOverlap) {
304         cbk.onWpsOverlap(1);
305     }
306     return 0;
307 }
308 
OnEventWpsTimeout(struct IWpaCallback * self,const char * ifName)309 int32_t OnEventWpsTimeout(struct IWpaCallback *self, const char *ifName)
310 {
311     if (ifName == nullptr) {
312         LOGE("OnEventWpsOverlap: invalid ifName!");
313         return 1;
314     }
315     LOGI("OnEventWpsTimeout: callback enter! ifName = %{public}s", ifName);
316     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
317     if (cbk.onWpsTimeOut) {
318         cbk.onWpsTimeOut(1);
319     }
320     return 0;
321 }
322 
OnEventAuthTimeout(struct IWpaCallback * self,const char * ifName)323 int32_t OnEventAuthTimeout(struct IWpaCallback *self, const char *ifName)
324 {
325     if (ifName == nullptr) {
326         LOGE("OnEventWpsOverlap: invalid ifName!");
327         return 1;
328     }
329     LOGI("OnEventAuthTimeout: callback enter! ifName = %{public}s", ifName);
330     const OHOS::Wifi::WifiEventCallback &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetCallbackInst(ifName);
331     if (g_currentWpaStatus == static_cast<int>(OHOS::Wifi::SupplicantState::FOUR_WAY_HANDSHAKE) &&
332         cbk.onWpaSsidWrongKey) {
333         LOGI("OnEventAuthTimeout, wrong password");
334         cbk.onWpaSsidWrongKey();
335         return 0;
336     }
337     if (cbk.onWpaAuthTimeout) {
338         cbk.onWpaAuthTimeout();
339     }
340     return 0;
341 }
342 
OnEventScanResult(struct IWpaCallback * self,const struct HdiWpaRecvScanResultParam * recvScanResultParam,const char * ifName)343 int32_t OnEventScanResult(struct IWpaCallback *self,
344     const struct HdiWpaRecvScanResultParam *recvScanResultParam, const char* ifName)
345 {
346     LOGI("OnEventScanResult: callback enter!");
347     if (recvScanResultParam == NULL) {
348         LOGE("OnEventScanResult: invalid parameter!");
349         return 1;
350     }
351 
352     const OHOS::Wifi::SupplicantEventCallback &cbk =
353         OHOS::Wifi::WifiSupplicantHalInterface::GetInstance().GetCallbackInst();
354     if (cbk.onScanNotify) {
355         cbk.onScanNotify(HAL_SINGLE_SCAN_OVER_OK);
356     }
357     return 0;
358 }
359 
onEventStaJoin(struct IHostapdCallback * self,const struct HdiApCbParm * apCbParm,const char * ifName)360 int32_t onEventStaJoin(struct IHostapdCallback *self, const struct HdiApCbParm *apCbParm, const char* ifName)
361 {
362     LOGI("onEvenStaJoin: callback enter!");
363     if (apCbParm == nullptr || apCbParm->content == NULL) {
364         LOGE("onEvenStaJoin: invalid parameter!");
365         return 1;
366     }
367     HalCallbackEvent event;
368     uint8_t len = 0;
369     char tmpBuf[WIFI_BSSID_LENGTH] = {0};
370     if (strncmp(apCbParm->content, "AP-STA-CONNECTED", strlen("AP-STA-CONNECTED")) == 0) {
371         event = HAL_CBK_CMD_STA_JOIN;
372         len = strlen("AP-STA-CONNECTED");
373     } else if (strncmp(apCbParm->content, "AP-STA-DISCONNECTED", strlen("AP-STA-DISCONNECTED")) == 0) {
374         event = HAL_CBK_CMD_STA_LEAVE;
375         len = strlen("AP-STA-DISCONNECTED");
376     } else {
377         LOGE("onEvenStaJoin: unknown content!");
378         return 1;
379     }
380 
381     if (strcpy_s(tmpBuf, sizeof(tmpBuf), apCbParm->content + len + 1) != 0) {
382         LOGE("onEvenStaJoin: strcpy_s failed!");
383     }
384 
385     const OHOS::Wifi::IWifiApMonitorEventCallback &cbk =
386             OHOS::Wifi::WifiApHalInterface::GetInstance().GetApCallbackInst(apCbParm->id);
387     if (cbk.onStaJoinOrLeave) {
388         OHOS::Wifi::WifiHalApConnectionNofify cbInfo;
389         cbInfo.type = static_cast<int>(event);
390         cbInfo.mac = tmpBuf;
391         cbk.onStaJoinOrLeave(cbInfo);
392     }
393     return 0;
394 }
395 
onEventApState(struct IHostapdCallback * self,const struct HdiApCbParm * apCbParm,const char * ifName)396 int32_t onEventApState(struct IHostapdCallback *self, const struct HdiApCbParm *apCbParm, const char* ifName)
397 {
398     LOGI("onEvenApState: callback enter!");
399     if (apCbParm == nullptr || apCbParm->content == NULL) {
400         LOGE("onEvenApState: invalid parameter!");
401         return 1;
402     }
403     HalCallbackEvent event;
404     if (strncmp(apCbParm->content, "AP-ENABLED", strlen("AP-ENABLED")) == 0) {
405         event = HAL_CBK_CMD_AP_ENABLE;
406     } else if (strncmp(apCbParm->content, "AP-DISABLED", strlen("AP-DISABLED")) == 0) {
407         event = HAL_CBK_CMD_AP_DISABLE;
408         if (GetExecDisable() == EXEC_DISABLE) {
409             SetExecDisable(0);
410             return 0;
411         }
412     } else if (strncmp(apCbParm->content, "CTRL-EVENT-TERMINATING", strlen("CTRL-EVENT-TERMINATING")) == 0) {
413         event = HAL_CBK_CMD_AP_DISABLE;
414     } else if (strncmp(apCbParm->content, "AP-STA-POSSIBLE-PSK-MISMATCH ",
415         strlen("AP-STA-POSSIBLE-PSK-MISMATCH ")) == 0) {
416         event = HAL_CBK_CMD_AP_STA_PSK_MISMATCH_EVENT;
417     } else if (strncmp(apCbParm->content, "AP-CSA-FINISHED ", strlen("AP-CSA-FINISHED ")) == 0) {
418         const OHOS::Wifi::IWifiApMonitorEventCallback &cbk =
419             OHOS::Wifi::WifiApHalInterface::GetInstance().GetApCallbackInst(apCbParm->id);
420         const std::string str(apCbParm->content);
421         if (cbk.onEventHostApdNotify) {
422             cbk.onEventHostApdNotify(str);
423         }
424         return 0;
425     } else {
426         return 1;
427     }
428 
429     const OHOS::Wifi::IWifiApMonitorEventCallback &cbk =
430             OHOS::Wifi::WifiApHalInterface::GetInstance().GetApCallbackInst(apCbParm->id);
431     if (cbk.onApEnableOrDisable) {
432         cbk.onApEnableOrDisable(static_cast<int>(event));
433     }
434     return 0;
435 }
436 
OnEventP2pStateChanged(int status)437 int32_t OnEventP2pStateChanged(int status)
438 {
439     LOGI("OnEventP2pStateChanged %{public}d", status);
440     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
441     if (cbk.onConnectSupplicant) {
442         cbk.onConnectSupplicant(status);
443     }
444     return 0;
445 }
446 
OnEventDeviceFound(struct IWpaCallback * self,const struct HdiP2pDeviceInfoParam * deviceInfoParam,const char * ifName)447 int32_t OnEventDeviceFound(struct IWpaCallback *self,
448     const struct HdiP2pDeviceInfoParam *deviceInfoParam, const char* ifName)
449 {
450     LOGI("OnEventDeviceFound");
451     if (deviceInfoParam == nullptr) {
452         return 1;
453     }
454     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
455     if (cbk.onDeviceFound) {
456         OHOS::Wifi::HalP2pDeviceFound cbInfo;
457         uint32_t srcAddressLen = deviceInfoParam->srcAddressLen;
458         char srcAddress[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
459         ConvertMacArr2String(deviceInfoParam->srcAddress, srcAddressLen, srcAddress, sizeof(srcAddress));
460         cbInfo.srcAddress = srcAddress;
461 
462         uint32_t p2pDeviceAddressLen = deviceInfoParam->p2pDeviceAddressLen;
463         char p2pDeviceAddress[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
464         ConvertMacArr2String(deviceInfoParam->p2pDeviceAddress, p2pDeviceAddressLen,
465             p2pDeviceAddress, sizeof(p2pDeviceAddress));
466         cbInfo.p2pDeviceAddress = p2pDeviceAddress;
467 
468         cbInfo.primaryDeviceType = (char *)(deviceInfoParam->primaryDeviceType);
469         cbInfo.deviceName = (char *)(deviceInfoParam->deviceName);
470         cbInfo.configMethods = deviceInfoParam->configMethods;
471         cbInfo.deviceCapabilities = deviceInfoParam->deviceCapabilities;
472         cbInfo.groupCapabilities = deviceInfoParam->groupCapabilities;
473         cbInfo.wfdDeviceInfo.insert(cbInfo.wfdDeviceInfo.begin(), deviceInfoParam->wfdDeviceInfo,
474             deviceInfoParam->wfdDeviceInfo + deviceInfoParam->wfdLength);
475         cbk.onDeviceFound(cbInfo);
476         LOGI("OnEventDeviceFound p2pDeviceAddress=%{private}s deviceName=%{private}s",
477             p2pDeviceAddress, deviceInfoParam->deviceName);
478     }
479     return 0;
480 }
481 
OnEventDeviceLost(struct IWpaCallback * self,const struct HdiP2pDeviceLostParam * deviceLostParam,const char * ifName)482 int32_t OnEventDeviceLost(struct IWpaCallback *self,
483     const struct HdiP2pDeviceLostParam *deviceLostParam, const char* ifName)
484 {
485     LOGI("OnEventDeviceLost");
486     if (deviceLostParam == nullptr) {
487         return 1;
488     }
489     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
490     if (cbk.onDeviceLost) {
491         uint32_t p2pDeviceAddressLen = deviceLostParam->p2pDeviceAddressLen;
492         char p2pDeviceAddress[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
493         ConvertMacArr2String(deviceLostParam->p2pDeviceAddress, p2pDeviceAddressLen,
494             p2pDeviceAddress, sizeof(p2pDeviceAddress));
495         cbk.onDeviceLost(p2pDeviceAddress);
496         LOGI("OnEventDeviceLost p2pDeviceAddress=%{private}s", p2pDeviceAddress);
497     }
498     return 0;
499 }
500 
OnEventGoNegotiationRequest(struct IWpaCallback * self,const struct HdiP2pGoNegotiationRequestParam * goNegotiationRequestParam,const char * ifName)501 int32_t OnEventGoNegotiationRequest(struct IWpaCallback *self,
502     const struct HdiP2pGoNegotiationRequestParam *goNegotiationRequestParam, const char* ifName)
503 {
504     LOGI("OnEventGoNegotiationRequest");
505     if (goNegotiationRequestParam == nullptr) {
506         return 1;
507     }
508     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
509     if (cbk.onGoNegotiationRequest) {
510         char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
511         ConvertMacArr2String(goNegotiationRequestParam->srcAddress,
512             goNegotiationRequestParam->srcAddressLen, address, sizeof(address));
513 
514         cbk.onGoNegotiationRequest(address, goNegotiationRequestParam->passwordId);
515     }
516     return 0;
517 }
518 
OnEventGoNegotiationCompleted(struct IWpaCallback * self,const struct HdiP2pGoNegotiationCompletedParam * goNegotiationCompletedParam,const char * ifName)519 int32_t OnEventGoNegotiationCompleted(struct IWpaCallback *self,
520     const struct HdiP2pGoNegotiationCompletedParam *goNegotiationCompletedParam, const char* ifName)
521 {
522     if (goNegotiationCompletedParam == nullptr) {
523         LOGI("goNegotiationCompletedParam is null");
524         return 1;
525     }
526     int status = goNegotiationCompletedParam->status;
527     LOGI("OnEventGoNegotiationCompleted, status is %{public}d", status);
528     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
529     if (status == 0) {
530         if (cbk.onGoNegotiationSuccess) {
531             cbk.onGoNegotiationSuccess();
532         }
533     } else {
534         if (cbk.onGoNegotiationFailure) {
535             cbk.onGoNegotiationFailure(status);
536         }
537     }
538     return 0;
539 }
540 
OnEventInvitationReceived(struct IWpaCallback * self,const struct HdiP2pInvitationReceivedParam * invitationReceivedParam,const char * ifName)541 int32_t OnEventInvitationReceived(struct IWpaCallback *self,
542     const struct HdiP2pInvitationReceivedParam *invitationReceivedParam, const char *ifName)
543 {
544     LOGI("OnEventInvitationReceived");
545     if (invitationReceivedParam == nullptr) {
546         return 1;
547     }
548     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
549     if (cbk.onInvitationReceived) {
550         OHOS::Wifi::HalP2pInvitationInfo cbInfo;
551         cbInfo.type = invitationReceivedParam->type;
552         cbInfo.persistentNetworkId = invitationReceivedParam->persistentNetworkId;
553         cbInfo.operatingFrequency = invitationReceivedParam->operatingFrequency;
554 
555         char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
556         ConvertMacArr2String(invitationReceivedParam->srcAddress,
557             invitationReceivedParam->srcAddressLen, address, sizeof(address));
558         cbInfo.srcAddress = address;
559 
560         char address1[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
561         ConvertMacArr2String(invitationReceivedParam->goDeviceAddress,
562             invitationReceivedParam->goDeviceAddressLen, address1, sizeof(address1));
563         cbInfo.goDeviceAddress = address1;
564 
565         char address2[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
566         ConvertMacArr2String(invitationReceivedParam->bssid,
567             invitationReceivedParam->bssidLen, address2, sizeof(address2));
568         cbInfo.bssid = address2;
569 
570         cbk.onInvitationReceived(cbInfo);
571     }
572     return 0;
573 }
574 
OnEventInvitationResult(struct IWpaCallback * self,const struct HdiP2pInvitationResultParam * invitationResultParam,const char * ifName)575 int32_t OnEventInvitationResult(struct IWpaCallback *self,
576     const struct HdiP2pInvitationResultParam *invitationResultParam, const char *ifName)
577 {
578     LOGI("OnEventInvitationResult");
579     if (invitationResultParam == nullptr) {
580         return 1;
581     }
582     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
583     if (cbk.onInvitationResult) {
584         char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
585         ConvertMacArr2String(invitationResultParam->bssid,
586             invitationResultParam->bssidLen, address, sizeof(address));
587         cbk.onInvitationResult(address, invitationResultParam->status);
588     }
589     return 0;
590 }
591 
OnEventGroupFormationSuccess(struct IWpaCallback * self,const char * ifName)592 int32_t OnEventGroupFormationSuccess(struct IWpaCallback *self, const char *ifName)
593 {
594     LOGI("OnEventGroupFormationSuccess");
595     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
596     if (cbk.onGroupFormationSuccess) {
597         cbk.onGroupFormationSuccess();
598     }
599     return 0;
600 }
601 
OnEventGroupFormationFailure(struct IWpaCallback * self,const char * reason,const char * ifName)602 int32_t OnEventGroupFormationFailure(struct IWpaCallback *self, const char *reason, const char *ifName)
603 {
604     LOGI("OnEventGroupFormationFailure");
605     if (reason == nullptr) {
606         return 1;
607     }
608     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
609     if (cbk.onGroupFormationFailure) {
610         cbk.onGroupFormationFailure(reason);
611     }
612     return 0;
613 }
614 
OnEventGroupStarted(struct IWpaCallback * self,const struct HdiP2pGroupStartedParam * groupStartedParam,const char * ifName)615 int32_t OnEventGroupStarted(struct IWpaCallback *self,
616     const struct HdiP2pGroupStartedParam *groupStartedParam, const char* ifName)
617 {
618     LOGI("OnEventGroupStarted");
619     if (groupStartedParam == nullptr) {
620         return 1;
621     }
622     char tempSsid[WIFI_SSID_LENGTH] = {0};
623     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
624     if (cbk.onGroupStarted) {
625         OHOS::Wifi::HalP2pGroupInfo cbInfo;
626         cbInfo.isGo = groupStartedParam->isGo;
627         cbInfo.isPersistent = groupStartedParam->isPersistent;
628         cbInfo.frequency = groupStartedParam->frequency;
629         cbInfo.groupName = (char *)(groupStartedParam->groupIfName);
630         StrSafeCopy(tempSsid, sizeof(tempSsid), (char *)groupStartedParam->ssid);
631         PrintfDecode((u8 *)tempSsid, sizeof(tempSsid), tempSsid);
632         cbInfo.ssid = (char *)(tempSsid);
633         cbInfo.psk = (char *)(groupStartedParam->psk);
634         cbInfo.passphrase = (char *)(groupStartedParam->passphrase);
635         LOGI("OnEventGroupStarted groupName=%{public}s ssid=%{private}s len=%{public}lu",
636             cbInfo.groupName.c_str(), OHOS::Wifi::SsidAnonymize(cbInfo.ssid).c_str(), cbInfo.ssid.size());
637 
638         char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
639         ConvertMacArr2String(groupStartedParam->goDeviceAddress,
640             groupStartedParam->goDeviceAddressLen, address, sizeof(address));
641         cbInfo.goDeviceAddress = address;
642 
643         cbk.onGroupStarted(cbInfo);
644     }
645     return 0;
646 }
647 
OnEventGroupInfoStarted(struct IWpaCallback * self,const struct HdiP2pGroupInfoStartedParam * groupStartedParam,const char * ifName)648 int32_t OnEventGroupInfoStarted(struct IWpaCallback *self,
649     const struct HdiP2pGroupInfoStartedParam *groupStartedParam, const char* ifName)
650 {
651     LOGI("OnEventGroupInfoStarted");
652     if (groupStartedParam == nullptr) {
653         return 1;
654     }
655     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
656     char tempSsid[WIFI_SSID_LENGTH] = {0};
657     if (cbk.onGroupStarted) {
658         OHOS::Wifi::HalP2pGroupInfo cbInfo;
659         cbInfo.isGo = groupStartedParam->isGo;
660         cbInfo.isPersistent = groupStartedParam->isPersistent;
661         cbInfo.frequency = groupStartedParam->frequency;
662         cbInfo.groupName = (char *)(groupStartedParam->groupIfName);
663         StrSafeCopy(tempSsid, sizeof(tempSsid), (char *)groupStartedParam->ssid);
664         PrintfDecode((u8 *)tempSsid, sizeof(tempSsid), tempSsid);
665         cbInfo.ssid = (char *)(tempSsid);
666         cbInfo.psk = (char *)(groupStartedParam->psk);
667         cbInfo.passphrase = (char *)(groupStartedParam->passphrase);
668         char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
669         char address1[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
670         ConvertMacArr2String(groupStartedParam->goDeviceAddress,
671             groupStartedParam->goDeviceAddressLen, address, sizeof(address));
672         ConvertMacArr2String(groupStartedParam->goRandomDeviceAddress,
673             groupStartedParam->goRandomDeviceAddressLen, address1, sizeof(address1));
674         LOGI("OnEventGroupInfoStarted address=%{private}s len %{public}d address1=%{private}s ",
675             address, groupStartedParam->goRandomDeviceAddressLen, address1);
676         cbInfo.goDeviceAddress = address;
677         cbInfo.goRandomAddress = address1;
678         cbk.onGroupStarted(cbInfo);
679     }
680     return 0;
681 }
682 
OnEventGroupRemoved(struct IWpaCallback * self,const struct HdiP2pGroupRemovedParam * groupRemovedParam,const char * ifName)683 int32_t OnEventGroupRemoved(struct IWpaCallback *self,
684     const struct HdiP2pGroupRemovedParam *groupRemovedParam, const char* ifName)
685 {
686     LOGI("OnEventGroupRemoved");
687     if (groupRemovedParam == nullptr) {
688         return 1;
689     }
690     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
691     if (cbk.onGroupRemoved) {
692         cbk.onGroupRemoved((char *)(groupRemovedParam->groupIfName), (groupRemovedParam->isGo == 1));
693     }
694     return 0;
695 }
696 
OnEventProvisionDiscoveryCompleted(struct IWpaCallback * self,const struct HdiP2pProvisionDiscoveryCompletedParam * provisionDiscoveryCompletedParam,const char * ifName)697 int32_t OnEventProvisionDiscoveryCompleted(struct IWpaCallback *self,
698     const struct HdiP2pProvisionDiscoveryCompletedParam *provisionDiscoveryCompletedParam, const char* ifName)
699 {
700     LOGI("OnEventProvisionDiscoveryCompleted enter");
701     if (provisionDiscoveryCompletedParam == nullptr) {
702         return 1;
703     }
704     LOGI("OnEventProvisionDiscoveryCompleted provDiscStatusCode=%{public}d",
705         provisionDiscoveryCompletedParam->provDiscStatusCode);
706     uint32_t addressLen = provisionDiscoveryCompletedParam->p2pDeviceAddressLen;
707     char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
708     ConvertMacArr2String(provisionDiscoveryCompletedParam->p2pDeviceAddress,
709         addressLen, address, sizeof(address));
710 
711     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
712     if (provisionDiscoveryCompletedParam->provDiscStatusCode == PD_STATUS_CODE_SHOW_PIN) {
713         if (cbk.onProvisionDiscoveryShowPin) {
714             cbk.onProvisionDiscoveryShowPin(address,
715                 (char *)(provisionDiscoveryCompletedParam->generatedPin));
716         }
717     } else if (provisionDiscoveryCompletedParam->provDiscStatusCode == PD_STATUS_CODE_ENTER_PIN) {
718         if (cbk.onProvisionDiscoveryEnterPin) {
719             cbk.onProvisionDiscoveryEnterPin(address);
720         }
721     } else if (provisionDiscoveryCompletedParam->provDiscStatusCode == PD_STATUS_CODE_PBC_REQ) {
722         if (cbk.onProvisionDiscoveryPbcRequest) {
723             cbk.onProvisionDiscoveryPbcRequest(address);
724         }
725     } else if (provisionDiscoveryCompletedParam->provDiscStatusCode == PD_STATUS_CODE_PBC_RSP) {
726         if (cbk.onProvisionDiscoveryPbcResponse) {
727         cbk.onProvisionDiscoveryPbcResponse(address);
728     }
729     } else if (provisionDiscoveryCompletedParam->provDiscStatusCode == PD_STATUS_CODE_FAIL) {
730         if (cbk.onProvisionDiscoveryFailure) {
731             cbk.onProvisionDiscoveryFailure();
732         }
733     }
734     return 0;
735 }
736 
OnEventFindStopped(struct IWpaCallback * self,const char * ifName)737 int32_t OnEventFindStopped(struct IWpaCallback *self, const char* ifName)
738 {
739     LOGI("OnEventFindStopped");
740     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
741     if (cbk.onFindStopped) {
742         cbk.onFindStopped();
743     }
744     return 0;
745 }
746 
OnEventServDiscReq(struct IWpaCallback * self,const struct HdiP2pServDiscReqInfoParam * servDiscReqInfoParam,const char * ifName)747 int32_t OnEventServDiscReq(struct IWpaCallback *self,
748     const struct HdiP2pServDiscReqInfoParam *servDiscReqInfoParam, const char* ifName)
749 {
750     LOGI("OnEventServDiscReq");
751     if (servDiscReqInfoParam == nullptr) {
752         return 1;
753     }
754     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
755     if (cbk.onP2pServDiscReq) {
756         OHOS::Wifi::HalP2pServDiscReqInfo cbInfo;
757         cbInfo.freq = servDiscReqInfoParam->freq;
758         cbInfo.dialogToken = servDiscReqInfoParam->dialogToken;
759         cbInfo.updateIndic = servDiscReqInfoParam->updateIndic;
760 
761         char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
762         ConvertMacArr2String(servDiscReqInfoParam->mac, servDiscReqInfoParam->macLen,
763             address, sizeof(address));
764         cbInfo.mac = address;
765 
766         if (servDiscReqInfoParam->tlvsLen > 0 && servDiscReqInfoParam->tlvs != nullptr) {
767             OHOS::Wifi::Char2Vec(servDiscReqInfoParam->tlvs, servDiscReqInfoParam->tlvsLen, cbInfo.tlvList);
768         }
769         cbk.onP2pServDiscReq(cbInfo);
770     }
771     return 0;
772 }
773 
OnEventServDiscResp(struct IWpaCallback * self,const struct HdiP2pServDiscRespParam * servDiscRespParam,const char * ifName)774 int32_t OnEventServDiscResp(struct IWpaCallback *self,
775     const struct HdiP2pServDiscRespParam *servDiscRespParam, const char* ifName)
776 {
777     LOGI("OnEventServDiscResp");
778     if (servDiscRespParam == nullptr) {
779         return 1;
780     }
781     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
782     if (cbk.onServiceDiscoveryResponse) {
783         std::vector<unsigned char> tlvList;
784         if (servDiscRespParam->tlvs != nullptr) {
785             OHOS::Wifi::Char2Vec(servDiscRespParam->tlvs, servDiscRespParam->tlvsLen, tlvList);
786         }
787         char address[WIFI_HDI_STR_MAC_LENGTH +1] = {0};
788         ConvertMacArr2String(servDiscRespParam->srcAddress, servDiscRespParam->srcAddressLen,
789             address, sizeof(address));
790         cbk.onServiceDiscoveryResponse(address, servDiscRespParam->updateIndicator, tlvList);
791     }
792     return 0;
793 }
794 
OnEventStaConnectState(struct IWpaCallback * self,const struct HdiP2pStaConnectStateParam * staConnectStateParam,const char * ifName)795 int32_t OnEventStaConnectState(struct IWpaCallback *self,
796     const struct HdiP2pStaConnectStateParam *staConnectStateParam, const char* ifName)
797 {
798     LOGI("OnEventStaConnectState");
799     if (staConnectStateParam == nullptr) {
800         return 1;
801     }
802     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
803     char srcAddress[WIFI_HDI_STR_MAC_LENGTH + 1] = {0};
804     char address[WIFI_HDI_STR_MAC_LENGTH + 1] = {0};
805     ConvertMacArr2String(staConnectStateParam->p2pDeviceAddress,
806         staConnectStateParam->p2pDeviceAddressLen, address, sizeof(address));
807     ConvertMacArr2String(staConnectStateParam->srcAddress,
808         staConnectStateParam->srcAddressLen, srcAddress, sizeof(srcAddress));
809     if (staConnectStateParam->state == 1) {
810         if (cbk.onStaAuthorized) {
811             cbk.onStaAuthorized(address, srcAddress);
812         }
813     } else {
814         if (cbk.onStaDeauthorized) {
815             cbk.onStaDeauthorized(address);
816         }
817     }
818     return 0;
819 }
820 
OnEventIfaceCreated(struct IWpaCallback * self,const struct HdiP2pIfaceCreatedParam * ifaceCreatedParam,const char * ifName)821 int32_t OnEventIfaceCreated(struct IWpaCallback *self,
822     const struct HdiP2pIfaceCreatedParam *ifaceCreatedParam, const char* ifName)
823 {
824     LOGI("OnEventIfaceCreated");
825     if (ifaceCreatedParam == nullptr) {
826         return 1;
827     }
828     const OHOS::Wifi::P2pHalCallback &cbk = OHOS::Wifi::WifiP2PHalInterface::GetInstance().GetP2pCallbackInst();
829     if (cbk.onP2pIfaceCreated) {
830         cbk.onP2pIfaceCreated(ifName, ifaceCreatedParam->isGo);
831     }
832     return 0;
833 }
834 
OnNativeProcessDeath(int status)835 void OnNativeProcessDeath(int status)
836 {
837     LOGI("OnNativeProcessDeath status=%{public}d", status);
838     const std::function<void(int)> &cbk = OHOS::Wifi::WifiStaHalInterface::GetInstance().GetDeathCallbackInst();
839     if (cbk) {
840         cbk(status);
841     }
842 }
843 #endif
844