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_hal_callback.h"
17 #include <securec.h>
18 #include "wifi_log.h"
19 #include "wifi_hal_crpc_server.h"
20 #include "wifi_hal_define.h"
21 #include "wifi_hal_common_func.h"
22 
23 #undef LOG_TAG
24 #define LOG_TAG "WifiHalCallback"
25 #define MAC_OFFSET 1
26 
EmitEventCallbackMsg(WifiHalEventCallbackMsg * pCbkMsg,WifiHalEvent event)27 static void EmitEventCallbackMsg(WifiHalEventCallbackMsg *pCbkMsg, WifiHalEvent event)
28 {
29     if (pCbkMsg == NULL) {
30         return;
31     }
32     RpcServer *server = GetRpcServer();
33     if (server == NULL) {
34         LOGE("Rpc server not exists!");
35         free(pCbkMsg);
36         pCbkMsg = NULL;
37         return;
38     }
39     if (PushBackCallbackMsg(event, pCbkMsg) != 0) {
40         free(pCbkMsg);
41         pCbkMsg = NULL;
42         return;
43     }
44     if (EmitEvent(server, event) < 0) {
45         PopBackCallbackMsg(event);
46         free(pCbkMsg);
47         pCbkMsg = NULL;
48     }
49     return;
50 }
51 
WifiHalCbNotifyScanEnd(int status)52 void WifiHalCbNotifyScanEnd(int status)
53 {
54     LOGI("Get Scan status: %{public}d, and begin push notify message", status);
55     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
56     if (pCbkMsg == NULL) {
57         LOGE("create callback message failed!");
58         return;
59     }
60     pCbkMsg->msg.scanStatus = status;
61     EmitEventCallbackMsg(pCbkMsg, WIFI_SCAN_INFO_NOTIFY_EVENT);
62     return;
63 }
64 
WifiHalCbNotifyConnectChanged(int status,int networkId,const char * pos)65 void WifiHalCbNotifyConnectChanged(int status, int networkId, const char *pos)
66 {
67     if (pos == NULL) {
68         LOGI("Get connect state changed, pos is NULL");
69         return;
70     }
71     LOGI("Get connect state changed, state: %{public}d, networkid = %{public}d", status, networkId);
72     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
73     if (pCbkMsg == NULL) {
74         LOGE("create callback message failed!");
75         return;
76     }
77     pCbkMsg->msg.connMsg.status = status;
78     pCbkMsg->msg.connMsg.networkId = networkId;
79     StrSafeCopy(pCbkMsg->msg.connMsg.bssid, WIFI_MAC_LENGTH + 1, pos);
80     EmitEventCallbackMsg(pCbkMsg, WIFI_CONNECT_CHANGED_NOTIFY_EVENT);
81     return;
82 }
83 
WifiHalCbNotifyDisConnectReason(int reason,const char * bssid)84 void WifiHalCbNotifyDisConnectReason(int reason, const char *bssid)
85 {
86     if (bssid == NULL) {
87         LOGI("Get connect state changed, pos is NULL");
88         return;
89     }
90     LOGI("Get disconnect state changed, reason: %{public}d", reason);
91     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
92     if (pCbkMsg == NULL) {
93         LOGE("create callback message failed!");
94         return;
95     }
96     pCbkMsg->msg.connMsg.status = reason;
97     StrSafeCopy(pCbkMsg->msg.connMsg.bssid, WIFI_MAC_LENGTH + 1, bssid);
98     EmitEventCallbackMsg(pCbkMsg, WIFI_STA_DISCONNECT_REASON_EVENT);
99     return;
100 }
101 
WifiHalCbNotifyBssidChanged(const char * reasonPos,const char * bssidPos)102 void WifiHalCbNotifyBssidChanged(const char *reasonPos, const char *bssidPos)
103 {
104     char reason[WIFI_REASON_LENGTH] = {0};
105     if (reasonPos == NULL || bssidPos == NULL) {
106         LOGE("reasonPos or bssidPos is NULL");
107         return;
108     }
109     char *reasonEnd = strchr(reasonPos, ' ');
110     if (reasonEnd != NULL) {
111         int reasonLen = reasonEnd - reasonPos;
112         reasonLen = reasonLen > WIFI_REASON_LENGTH ? WIFI_REASON_LENGTH : reasonLen;
113         if (memcpy_s(reason, sizeof(reason), reasonPos, reasonLen) != EOK) {
114             LOGW("failed to copy the reason!");
115         }
116     }
117 
118     LOGI("bssid changed event, reason: %{public}s, bssid = %{private}s", reason, bssidPos);
119     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
120     if (pCbkMsg == NULL) {
121         LOGE("create callback message failed!");
122         return;
123     }
124     if (memcpy_s(pCbkMsg->msg.bssidChangedMsg.reason, WIFI_REASON_LENGTH, reason, WIFI_REASON_LENGTH) != EOK) {
125         LOGW("failed to copy the reason!");
126     }
127     if (memcpy_s(pCbkMsg->msg.bssidChangedMsg.bssid, WIFI_MAC_LENGTH + 1, bssidPos, WIFI_MAC_LENGTH + 1) != EOK) {
128         LOGW("failed to copy the bssid!");
129     }
130     EmitEventCallbackMsg(pCbkMsg, WIFI_BSSID_CHANGED_NOTIFY_EVENT);
131 }
132 
WifiHalCbNotifyWpaStateChange(int status)133 void WifiHalCbNotifyWpaStateChange(int status)
134 {
135     LOGI("wpa state changed, state: %{public}d, and begin push notify message", status);
136     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
137     if (pCbkMsg == NULL) {
138         LOGE("create callback message failed!");
139         return;
140     }
141     pCbkMsg->msg.connMsg.status = status;
142     EmitEventCallbackMsg(pCbkMsg, WIFI_WPA_STATE_EVENT);
143     return;
144 }
145 
WifiHalCbNotifyWrongKey(int status)146 void WifiHalCbNotifyWrongKey(int status)
147 {
148     LOGI("wrong key, state: %{public}d, and begin push notify message", status);
149     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
150     if (pCbkMsg == NULL) {
151         LOGE("create callback message failed!");
152         return;
153     }
154     pCbkMsg->msg.connMsg.status = status;
155     EmitEventCallbackMsg(pCbkMsg, WIFI_SSID_WRONG_KEY);
156     return;
157 }
158 
WifiHalCbNotifyConnectionFull(int status)159 void WifiHalCbNotifyConnectionFull(int status)
160 {
161     LOGI("connection is full, state: %{public}d, and begin push notify message", status);
162     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
163     if (pCbkMsg == NULL) {
164         LOGE("create callback message failed!");
165         return;
166     }
167 
168     pCbkMsg->msg.connMsg.status = status;
169     EmitEventCallbackMsg(pCbkMsg, WIFI_CONNECTION_FULL_EVENT);
170     return;
171 }
172 
WifiHalCbNotifyConnectionReject(int status)173 void WifiHalCbNotifyConnectionReject(int status)
174 {
175     LOGI("connection is eeject, state: %{public}d, and begin push notify message", status);
176     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
177     if (pCbkMsg == NULL) {
178         LOGE("create callback message failed!");
179         return;
180     }
181 
182     pCbkMsg->msg.connMsg.status = status;
183     EmitEventCallbackMsg(pCbkMsg, WIFI_CONNECTION_REJECT_EVENT);
184     return;
185 }
186 
WifiHalCbNotifyWpsOverlap(int event)187 void WifiHalCbNotifyWpsOverlap(int event)
188 {
189     LOGI("wps overlap, state: %{public}d, and begin push notify message", event);
190     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
191     if (pCbkMsg == NULL) {
192         LOGE("create callback message failed!");
193         return;
194     }
195     pCbkMsg->msg.connMsg.status = event;
196     EmitEventCallbackMsg(pCbkMsg, WIFI_WPS_OVERLAP);
197     return;
198 }
199 
WifiHalCbNotifyWpsTimeOut(int event)200 void WifiHalCbNotifyWpsTimeOut(int event)
201 {
202     LOGI("wps time out, state: %{public}d, and begin push notify message", event);
203     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
204     if (pCbkMsg == NULL) {
205         LOGE("create callback message failed!");
206         return;
207     }
208     pCbkMsg->msg.connMsg.status = event;
209     EmitEventCallbackMsg(pCbkMsg, WIFI_WPS_TIME_OUT);
210     return;
211 }
212 
WifiHalCbStaJoin(const char * content,int id)213 void WifiHalCbStaJoin(const char *content, int id)
214 {
215     if (content == NULL) {
216         LOGD("Get hostapd Sta join content is NULL");
217         return;
218     }
219     LOGD("Get hostapd Sta join, instance id:%{public}d", id);
220     WifiHalEvent event;
221     char tmpBuf[WIFI_BSSID_LENGTH] = {0};
222     if (strncmp("AP-STA-CONNECTED", content, strlen("AP-STA-CONNECTED")) == 0) {
223         event = WIFI_STA_JOIN_EVENT;
224         StrSafeCopy(tmpBuf, sizeof(tmpBuf), content + strlen("AP-STA-CONNECTED") + MAC_OFFSET);
225     } else if (strncmp("AP-STA-DISCONNECTED", content, strlen("AP-STA-DISCONNECTED")) == 0) {
226         event = WIFI_STA_LEAVE_EVENT;
227         StrSafeCopy(tmpBuf, sizeof(tmpBuf), content + strlen("AP-STA-DISCONNECTED") + MAC_OFFSET);
228     } else {
229         return;
230     }
231     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
232     if (pCbkMsg == NULL) {
233         LOGE("hostapd create callback message failed!");
234         return;
235     }
236     pCbkMsg->msg.ifMsg.id = id;
237     pCbkMsg->msg.ifMsg.type = event;
238     StrSafeCopy(pCbkMsg->msg.ifMsg.ifname, sizeof(pCbkMsg->msg.ifMsg.ifname), tmpBuf);
239     EmitEventCallbackMsg(pCbkMsg, event);
240     return;
241 }
242 
WifiHalCbApState(const char * content,int id)243 void WifiHalCbApState(const char *content, int id)
244 {
245     if (content == NULL) {
246         LOGD("Get hostapd status changed content is NULL");
247         return;
248     }
249     LOGD("Get hostapd status changed, instance id:%{public}d", id);
250     WifiHalEvent event;
251     if (strncmp(content, "AP-ENABLED", strlen("AP-ENABLED")) == 0) {
252         event = WIFI_AP_ENABLE_EVENT;
253     } else if (strncmp(content, "AP-DISABLED", strlen("AP-DISABLED")) == 0 ||
254                strncmp(content, "CTRL-EVENT-TERMINATING", strlen("CTRL-EVENT-TERMINATING")) == 0) {
255         event = WIFI_AP_DISABLE_EVENT;
256     } else if (strncmp(content, "AP-STA-POSSIBLE-PSK-MISMATCH ", strlen("AP-STA-POSSIBLE-PSK-MISMATCH ")) == 0) {
257         event = AP_STA_PSK_MISMATH_EVENT;
258     } else {
259         return;
260     }
261 
262     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
263     if (pCbkMsg == NULL) {
264         LOGE("hostapd create callback message failed!");
265         return;
266     }
267     pCbkMsg->msg.ifMsg.type = event;
268     pCbkMsg->msg.ifMsg.id = id;
269     EmitEventCallbackMsg(pCbkMsg, event);
270     return;
271 }
272 
WifiP2pHalCbNotifyConnectSupplicant(int state)273 void WifiP2pHalCbNotifyConnectSupplicant(int state)
274 {
275     LOGI("P2p supplicant connect even : %{public}d", state);
276     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
277     if (pCbkMsg == NULL) {
278         LOGE("create callback message failed!");
279         return;
280     }
281     pCbkMsg->msg.scanStatus = state;
282     EmitEventCallbackMsg(pCbkMsg, WIFI_P2P_SUP_CONNECTION_EVENT);
283     return;
284 }
285 
P2pHalCbDeviceFound(const P2pDeviceInfo * device)286 void P2pHalCbDeviceFound(const P2pDeviceInfo *device)
287 {
288     if (device == NULL) {
289         return;
290     }
291     ANONYMIZE_LOGI("P2p device found event deviceName: %{public}s", device->deviceName);
292     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
293     if (pCbkMsg == NULL) {
294         LOGE("create callback message failed!");
295         return;
296     }
297     pCbkMsg->msg.deviceInfo = *device;
298     EmitEventCallbackMsg(pCbkMsg, P2P_DEVICE_FOUND_EVENT);
299     return;
300 }
301 
P2pHalCbDeviceLost(const char * p2pDeviceAddress)302 void P2pHalCbDeviceLost(const char *p2pDeviceAddress)
303 {
304     if (p2pDeviceAddress == NULL) {
305         LOGI("P2p device lost event p2pDeviceAddress is NULL");
306         return;
307     }
308     LOGI("P2p device lost event p2pDeviceAddress: %{private}s", p2pDeviceAddress);
309     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
310     if (pCbkMsg == NULL) {
311         LOGE("create callback message failed!");
312         return;
313     }
314     if (strncpy_s(pCbkMsg->msg.connMsg.bssid, sizeof(pCbkMsg->msg.connMsg.bssid), p2pDeviceAddress,
315         sizeof(pCbkMsg->msg.connMsg.bssid) - 1) != EOK) {
316         free(pCbkMsg);
317         pCbkMsg = NULL;
318         return;
319     }
320     EmitEventCallbackMsg(pCbkMsg, P2P_DEVICE_LOST_EVENT);
321     return;
322 }
323 
P2pHalCbGoNegotiationRequest(const char * srcAddress,short passwordId)324 void P2pHalCbGoNegotiationRequest(const char *srcAddress, short passwordId)
325 {
326     if (srcAddress == NULL) {
327         LOGI("P2p go negotiation request event srcAddress is NULL");
328         return;
329     }
330     LOGI("P2p go negotiation request event srcAddress: %{private}s, passwordId: %{private}d", srcAddress, passwordId);
331     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
332     if (pCbkMsg == NULL) {
333         LOGE("create callback message failed!");
334         return;
335     }
336     pCbkMsg->msg.connMsg.status = passwordId;
337     if (strncpy_s(pCbkMsg->msg.connMsg.bssid, sizeof(pCbkMsg->msg.connMsg.bssid), srcAddress,
338         sizeof(pCbkMsg->msg.connMsg.bssid) - 1) != EOK) {
339         free(pCbkMsg);
340         pCbkMsg = NULL;
341         return;
342     }
343     EmitEventCallbackMsg(pCbkMsg, P2P_GO_NEGOTIATION_REQUEST_EVENT);
344     return;
345 }
346 
P2pHalCbGoNegotiationSuccess()347 void P2pHalCbGoNegotiationSuccess()
348 {
349     LOGI("P2p go negotiation success event");
350     RpcServer *server = GetRpcServer();
351     if (server == NULL) {
352         LOGE("Rpc server not exists!");
353         return;
354     }
355     EmitEvent(server, P2P_GO_NEGOTIATION_SUCCESS_EVENT);
356     return;
357 }
358 
P2pHalCbGoNegotiationFailure(int status)359 void P2pHalCbGoNegotiationFailure(int status)
360 {
361     LOGI("P2p go negotiation failure event status: %{public}d", status);
362     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
363     if (pCbkMsg == NULL) {
364         LOGE("create callback message failed!");
365         return;
366     }
367     pCbkMsg->msg.scanStatus = status;
368     EmitEventCallbackMsg(pCbkMsg, P2P_GO_NEGOTIATION_FAILURE_EVENT);
369     return;
370 }
371 
P2pHalCbP2pChannelSwitch(int freq)372 void P2pHalCbP2pChannelSwitch(int freq)
373 {
374     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
375     if (pCbkMsg == NULL) {
376         LOGE("create callback message failed!");
377         return;
378     }
379     pCbkMsg->msg.serDiscReqInfo.freq = freq;
380     EmitEventCallbackMsg(pCbkMsg, P2P_CHANNEL_SWITCH);
381     return;
382 }
383 
P2pHalCbP2pConnectFailed(const char * bssid,int reason)384 void P2pHalCbP2pConnectFailed(const char *bssid, int reason)
385 {
386     if (bssid == NULL) {
387         LOGE("P2p connect failed event bssid is NULL");
388         return;
389     }
390     LOGI("P2p connect failed event bssid: %{private}s, reason: %{public}d", bssid, reason);
391     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
392     if (pCbkMsg == NULL) {
393         LOGE("create callback message failed!");
394         return;
395     }
396     pCbkMsg->msg.connMsg.status = reason;
397     if (strncpy_s(pCbkMsg->msg.connMsg.bssid, sizeof(pCbkMsg->msg.connMsg.bssid), bssid,
398         sizeof(pCbkMsg->msg.connMsg.bssid) - 1) != EOK) {
399         free(pCbkMsg);
400         pCbkMsg = NULL;
401         return;
402     }
403     EmitEventCallbackMsg(pCbkMsg, P2P_CONNECT_FAILED);
404     return;
405 }
406 
P2pHalCbInvitationReceived(const P2pInvitationInfo * info)407 void P2pHalCbInvitationReceived(const P2pInvitationInfo *info)
408 {
409     if (info == NULL) {
410         return;
411     }
412     LOGI("P2p invitation received event srcAddress: %{private}s", info->srcAddress);
413     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
414     if (pCbkMsg == NULL) {
415         LOGE("create callback message failed!");
416         return;
417     }
418     pCbkMsg->msg.invitaInfo = *info;
419     EmitEventCallbackMsg(pCbkMsg, P2P_INVITATION_RECEIVED_EVENT);
420     return;
421 }
422 
P2pHalCbInvitationResult(const char * bssid,int status)423 void P2pHalCbInvitationResult(const char *bssid, int status)
424 {
425     if (bssid == NULL) {
426         LOGI("P2p invitation result event bssid is NULL");
427         return;
428     }
429     LOGI("P2p invitation result event bssid: %{private}s, status: %{public}d", bssid, status);
430     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
431     if (pCbkMsg == NULL) {
432         LOGE("create callback message failed!");
433         return;
434     }
435     pCbkMsg->msg.invitaInfo.persistentNetworkId = status;
436     if (strncpy_s(pCbkMsg->msg.invitaInfo.bssid, sizeof(pCbkMsg->msg.invitaInfo.bssid), bssid,
437         sizeof(pCbkMsg->msg.invitaInfo.bssid) - 1) != EOK) {
438         free(pCbkMsg);
439         pCbkMsg = NULL;
440         return;
441     }
442     EmitEventCallbackMsg(pCbkMsg, P2P_INVITATION_RESULT_EVENT);
443     return;
444 }
445 
P2pHalCbGroupFormationSuccess()446 void P2pHalCbGroupFormationSuccess()
447 {
448     LOGI("P2p group formation success event");
449     RpcServer *server = GetRpcServer();
450     if (server == NULL) {
451         LOGE("Rpc server not exists!");
452         return;
453     }
454     EmitEvent(server, P2P_GROUP_FORMATION_SUCCESS_EVENT);
455     return;
456 }
457 
P2pHalCbGroupFormationFailure(const char * reason)458 void P2pHalCbGroupFormationFailure(const char *reason)
459 {
460     if (reason == NULL) {
461         LOGI("P2p group formation failure event reason is NULL");
462         return;
463     }
464     LOGW("P2p group formation failure event reason: %{public}s", reason);
465     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
466     if (pCbkMsg == NULL) {
467         LOGE("create callback message failed!");
468         return;
469     }
470     if (strncpy_s(pCbkMsg->msg.invitaInfo.bssid, sizeof(pCbkMsg->msg.invitaInfo.bssid), reason,
471         sizeof(pCbkMsg->msg.invitaInfo.bssid) - 1) != EOK) {
472         free(pCbkMsg);
473         pCbkMsg = NULL;
474         return;
475     }
476     EmitEventCallbackMsg(pCbkMsg, P2P_GROUP_FORMATION_FAILURE_EVENT);
477     return;
478 }
479 
P2pHalCbGroupStarted(const P2pGroupInfo * info)480 void P2pHalCbGroupStarted(const P2pGroupInfo *info)
481 {
482     if (info == NULL) {
483         return;
484     }
485     LOGI("P2p group started event groupIfName: %{public}s, ssid len: %{public}zu", info->groupIfName,
486         strlen(info->ssid));
487     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
488     if (pCbkMsg == NULL) {
489         LOGE("create callback message failed!");
490         return;
491     }
492     pCbkMsg->msg.groupInfo = *info;
493     EmitEventCallbackMsg(pCbkMsg, P2P_GROUP_STARTED_EVENT);
494     return;
495 }
496 
P2pHalCbGroupRemoved(const char * groupIfName,int isGo)497 void P2pHalCbGroupRemoved(const char *groupIfName, int isGo)
498 {
499     if (groupIfName == NULL) {
500         LOGI("P2p group removed event groupIfName is NULL");
501         return;
502     }
503     LOGW("P2p group removed event groupIfName: %{public}s, isGo: %{public}d", groupIfName, isGo);
504     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
505     if (pCbkMsg == NULL) {
506         LOGE("create callback message failed!");
507         return;
508     }
509     pCbkMsg->msg.groupInfo.isGo = isGo;
510     if (strncpy_s(pCbkMsg->msg.groupInfo.groupIfName, sizeof(pCbkMsg->msg.groupInfo.groupIfName), groupIfName,
511         sizeof(pCbkMsg->msg.groupInfo.groupIfName) - 1) != EOK) {
512         free(pCbkMsg);
513         pCbkMsg = NULL;
514         return;
515     }
516     EmitEventCallbackMsg(pCbkMsg, P2P_GROUP_REMOVED_EVENT);
517     return;
518 }
519 
P2pHalCbclientRemoved(const char * deviceMac)520 void P2pHalCbclientRemoved(const char *deviceMac)
521 {
522     if (deviceMac == NULL) {
523         LOGI("P2p group removed event deviceMac is NULL");
524         return;
525     }
526     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
527     if (pCbkMsg == NULL) {
528         LOGE("create callback message failed!");
529         return;
530     }
531     if (strncpy_s(pCbkMsg->msg.deviceInfo.p2pDeviceAddress, sizeof(pCbkMsg->msg.deviceInfo.p2pDeviceAddress),
532         deviceMac, sizeof(pCbkMsg->msg.deviceInfo.p2pDeviceAddress) - 1) != EOK) {
533         free(pCbkMsg);
534         return;
535     }
536     EmitEventCallbackMsg(pCbkMsg, P2P_CLIENT_REMOVED_EVENT);
537     return;
538 }
539 
P2pHalCbProvisionDiscoveryPbcRequest(const char * address)540 void P2pHalCbProvisionDiscoveryPbcRequest(const char *address)
541 {
542     if (address == NULL) {
543         LOGI("P2p provision discovery pbc request event address is NULL");
544         return;
545     }
546     LOGI("P2p provision discovery pbc request event address: %{private}s", address);
547     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
548     if (pCbkMsg == NULL) {
549         LOGE("create callback message failed!");
550         return;
551     }
552     if (strncpy_s(pCbkMsg->msg.deviceInfo.srcAddress, sizeof(pCbkMsg->msg.deviceInfo.srcAddress), address,
553         sizeof(pCbkMsg->msg.deviceInfo.srcAddress) - 1) != EOK) {
554         free(pCbkMsg);
555         pCbkMsg = NULL;
556         return;
557     }
558     EmitEventCallbackMsg(pCbkMsg, P2P_PROV_DISC_PBC_REQ_EVENT);
559     return;
560 }
561 
P2pHalCbProvisionDiscoveryPbcResponse(const char * address)562 void P2pHalCbProvisionDiscoveryPbcResponse(const char *address)
563 {
564     if (address == NULL) {
565         LOGI("P2p provision discovery pbc response event address is NULL");
566         return;
567     }
568     LOGI("P2p provision discovery pbc response event address: %{private}s", address);
569     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
570     if (pCbkMsg == NULL) {
571         LOGE("create callback message failed!");
572         return;
573     }
574     if (strncpy_s(pCbkMsg->msg.deviceInfo.srcAddress, sizeof(pCbkMsg->msg.deviceInfo.srcAddress), address,
575         sizeof(pCbkMsg->msg.deviceInfo.srcAddress) - 1) != EOK) {
576         free(pCbkMsg);
577         pCbkMsg = NULL;
578         return;
579     }
580     EmitEventCallbackMsg(pCbkMsg, P2P_PROV_DISC_PBC_RSP_EVENT);
581     return;
582 }
583 
P2pHalCbProvisionDiscoveryEnterPin(const char * address)584 void P2pHalCbProvisionDiscoveryEnterPin(const char *address)
585 {
586     if (address == NULL) {
587         LOGI("P2p provision discovery enter pin event address is NULL");
588         return;
589     }
590     LOGI("P2p provision discovery enter pin event address: %{private}s", address);
591     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
592     if (pCbkMsg == NULL) {
593         LOGE("create callback message failed!");
594         return;
595     }
596     if (strncpy_s(pCbkMsg->msg.deviceInfo.srcAddress, sizeof(pCbkMsg->msg.deviceInfo.srcAddress), address,
597         sizeof(pCbkMsg->msg.deviceInfo.srcAddress) - 1) != EOK) {
598         free(pCbkMsg);
599         pCbkMsg = NULL;
600         return;
601     }
602     EmitEventCallbackMsg(pCbkMsg, P2P_PROV_DISC_ENTER_PIN_EVENT);
603     return;
604 }
605 
P2pHalCbProvisionDiscoveryShowPin(const char * address,const char * pin)606 void P2pHalCbProvisionDiscoveryShowPin(const char *address, const char *pin)
607 {
608     if (address == NULL || pin == NULL) {
609         LOGI("P2p provision discovery show pin event address or pin is NULL");
610         return;
611     }
612     LOGI("P2p provision discovery show pin event address: %{private}s, pin: %{private}s", address, pin);
613     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
614     if (pCbkMsg == NULL) {
615         LOGE("create callback message failed!");
616         return;
617     }
618     if (strncpy_s(pCbkMsg->msg.deviceInfo.srcAddress, sizeof(pCbkMsg->msg.deviceInfo.srcAddress), address,
619         sizeof(pCbkMsg->msg.deviceInfo.srcAddress) - 1) != EOK ||
620         strncpy_s(pCbkMsg->msg.deviceInfo.deviceName, sizeof(pCbkMsg->msg.deviceInfo.deviceName), pin,
621         sizeof(pCbkMsg->msg.deviceInfo.deviceName) - 1) != EOK) {
622         free(pCbkMsg);
623         pCbkMsg = NULL;
624         return;
625     }
626     EmitEventCallbackMsg(pCbkMsg, P2P_PROV_DISC_SHOW_PIN_EVENT);
627     return;
628 }
629 
P2pHalCbProvisionDiscoveryFailure()630 void P2pHalCbProvisionDiscoveryFailure()
631 {
632     LOGW("P2p provision discovery failure event");
633     RpcServer *server = GetRpcServer();
634     if (server == NULL) {
635         LOGE("Rpc server not exists!");
636         return;
637     }
638     EmitEvent(server, P2P_PROV_DISC_FAILURE_EVENT);
639     return;
640 }
641 
P2pHalCbFindStopped()642 void P2pHalCbFindStopped()
643 {
644     LOGW("P2p find stopped event");
645     RpcServer *server = GetRpcServer();
646     if (server == NULL) {
647         LOGE("Rpc server not exists!");
648         return;
649     }
650     EmitEvent(server, P2P_FIND_STOPPED_EVENT);
651     return;
652 }
653 
P2pHalCbServiceDiscoveryResponse(const P2pServDiscRespInfo * info)654 void P2pHalCbServiceDiscoveryResponse(const P2pServDiscRespInfo *info)
655 {
656     if (info == NULL) {
657         return;
658     }
659     LOGI("P2p service discovery response event srcAddress: %{private}s", info->srcAddress);
660     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
661     if (pCbkMsg == NULL) {
662         LOGE("create callback message failed!");
663         return;
664     }
665     pCbkMsg->msg.serverInfo = *info;
666     if (info->tlvs != NULL) { // deep copy
667         unsigned len = strlen(info->tlvs) + 1;
668         if (len == 0) {
669             free(pCbkMsg);
670             pCbkMsg = NULL;
671             return;
672         }
673         pCbkMsg->msg.serverInfo.tlvs = (char *)calloc(len, sizeof(char));
674         if (pCbkMsg->msg.serverInfo.tlvs == NULL) {
675             free(pCbkMsg);
676             pCbkMsg = NULL;
677             return;
678         }
679         if (strncpy_s(pCbkMsg->msg.serverInfo.tlvs, len, info->tlvs, len - 1) != EOK) {
680             free(pCbkMsg->msg.serverInfo.tlvs);
681             pCbkMsg->msg.serverInfo.tlvs = NULL;
682             free(pCbkMsg);
683             pCbkMsg = NULL;
684             return;
685         }
686     }
687     EmitEventCallbackMsg(pCbkMsg, P2P_SERV_DISC_RESP_EVENT);
688     return;
689 }
690 
P2pHalCbStaConnectState(const char * p2pDeviceAddress,const char * p2pGroupAddress,int state)691 void P2pHalCbStaConnectState(const char *p2pDeviceAddress, const char *p2pGroupAddress, int state)
692 {
693     if (p2pDeviceAddress == NULL) {
694         LOGI("P2p sta authorized/deauthorized event devAddress is NULL");
695         return;
696     }
697     LOGI("P2p sta authorized/deauthorized event devAddress: %{private}s", p2pDeviceAddress);
698     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
699     if (pCbkMsg == NULL) {
700         LOGE("create callback message failed!");
701         return;
702     }
703     if (strncpy_s(pCbkMsg->msg.deviceInfo.p2pDeviceAddress, sizeof(pCbkMsg->msg.deviceInfo.p2pDeviceAddress),
704         p2pDeviceAddress, sizeof(pCbkMsg->msg.deviceInfo.p2pDeviceAddress) - 1) != EOK) {
705         free(pCbkMsg);
706         pCbkMsg = NULL;
707         return;
708     }
709     if (strncpy_s(pCbkMsg->msg.deviceInfo.p2pGroupAddress, sizeof(pCbkMsg->msg.deviceInfo.p2pGroupAddress),
710         p2pGroupAddress, sizeof(pCbkMsg->msg.deviceInfo.p2pGroupAddress) - 1) != EOK) {
711         free(pCbkMsg);
712         return;
713     }
714     EmitEventCallbackMsg(pCbkMsg, ((state == 0) ? AP_STA_DISCONNECTED_EVENT : AP_STA_CONNECTED_EVENT));
715     return;
716 }
717 
P2pHalCbConnectSupplicantFailed()718 void P2pHalCbConnectSupplicantFailed()
719 {
720     LOGW("P2p supplicant connect Failed event");
721     RpcServer *server = GetRpcServer();
722     if (server == NULL) {
723         LOGE("Rpc server not exists!");
724         return;
725     }
726     EmitEvent(server, SUP_CONN_FAILED_EVENT);
727     return;
728 }
729 
P2pHalCbServDiscReq(const P2pServDiscReqInfo * info)730 void P2pHalCbServDiscReq(const P2pServDiscReqInfo *info)
731 {
732     LOGI("P2p service discovery request event");
733     if (info == NULL) {
734         return;
735     }
736     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
737     if (pCbkMsg == NULL) {
738         LOGE("create callback message failed!");
739         return;
740     }
741     pCbkMsg->msg.serDiscReqInfo = *info;
742     if (info->tlvs != NULL) { // deep copy
743         unsigned len = strlen(info->tlvs) + 1;
744         if (len == 0) {
745             free(pCbkMsg);
746             pCbkMsg = NULL;
747             return;
748         }
749         pCbkMsg->msg.serDiscReqInfo.tlvs = (char *)calloc(len, sizeof(char));
750         if (pCbkMsg->msg.serDiscReqInfo.tlvs == NULL) {
751             free(pCbkMsg);
752             pCbkMsg = NULL;
753             return;
754         }
755         if (strncpy_s(pCbkMsg->msg.serDiscReqInfo.tlvs, len, info->tlvs, len - 1) != EOK) {
756             free(pCbkMsg->msg.serDiscReqInfo.tlvs);
757             pCbkMsg->msg.serDiscReqInfo.tlvs = NULL;
758             free(pCbkMsg);
759             pCbkMsg = NULL;
760             return;
761         }
762     }
763     EmitEventCallbackMsg(pCbkMsg, P2P_SERV_DISC_REQ_EVENT);
764     return;
765 }
766 
P2pHalCbP2pIfaceCreated(const char * ifName,int isGo)767 void P2pHalCbP2pIfaceCreated(const char *ifName, int isGo)
768 {
769     if (ifName == NULL) {
770         LOGE("P2p interface created event ifName is NULL");
771         return;
772     }
773     LOGI("P2p interface created event ifName: %{public}s, isGo: %{public}d", ifName, isGo);
774     WifiHalEventCallbackMsg *pCbkMsg = (WifiHalEventCallbackMsg *)calloc(1, sizeof(WifiHalEventCallbackMsg));
775     if (pCbkMsg == NULL) {
776         LOGE("create callback message failed!");
777         return;
778     }
779     pCbkMsg->msg.ifMsg.type = isGo;
780     if (strncpy_s(pCbkMsg->msg.ifMsg.ifname, sizeof(pCbkMsg->msg.ifMsg.ifname), ifName,
781         sizeof(pCbkMsg->msg.ifMsg.ifname) - 1) != EOK) {
782         free(pCbkMsg);
783         pCbkMsg = NULL;
784         return;
785     }
786     EmitEventCallbackMsg(pCbkMsg, P2P_IFACE_CREATED_EVENT);
787 }
788