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 "i_wifi.h"
17 #include <securec.h>
18 #include <stdlib.h>
19 #include "client.h"
20 #include "context.h"
21 #include "i_wifi_chip.h"
22 #include "i_wifi_chip_event_callback.h"
23 #include "i_wifi_event_callback.h"
24 #include "i_wifi_event_p2p_callback.h"
25 #include "i_wifi_hotspot_iface.h"
26 #include "i_wifi_p2p_iface.h"
27 #include "i_wifi_public_func.h"
28 #include "i_wifi_sta_iface.h"
29 #include "i_wifi_supplicant_iface.h"
30 #include "serial.h"
31 #include "wifi_idl_inner_interface.h"
32 #include "wifi_native_define.h"
33 
34 #ifndef __UT__
35 #include "wifi_log.h"
36 #else
37 #define static
38 #define LOGI(...)
39 #define LOGE(...)
40 #endif
41 
42 #undef LOG_TAG
43 #define LOG_TAG "WifiIdlIWifi"
44 
GetWifiChip(uint8_t id,IWifiChip * chip)45 WifiErrorNo GetWifiChip(uint8_t id, IWifiChip *chip)
46 {
47     RpcClient *client = GetChipRpcClient();
48     LockRpcClient(client);
49     Context *context = client->context;
50     WriteBegin(context, 0);
51     WriteFunc(context, "GetWifiChip");
52     WriteInt(context, id);
53     WriteEnd(context);
54     if (RpcClientCall(client, "GetWifiChip") != WIFI_HAL_OPT_OK) {
55         return WIFI_HAL_OPT_FAILED;
56     }
57     int result = WIFI_HAL_OPT_FAILED;
58     ReadInt(context, &result);
59     if (result != WIFI_HAL_OPT_OK) {
60         LOGE("server GetWifiChip deal failed!");
61     } else {
62         /* read IWifiChip struct */
63         ReadInt(context, &(chip->i));
64     }
65     ReadClientEnd(client);
66     UnlockRpcClient(client);
67     return result;
68 }
69 
GetWifiChipIds(uint8_t * ids,int32_t * size)70 WifiErrorNo GetWifiChipIds(uint8_t *ids, int32_t *size)
71 {
72     RpcClient *client = GetChipRpcClient();
73     LockRpcClient(client);
74     Context *context = client->context;
75     WriteBegin(context, 0);
76     WriteFunc(context, "GetWifiChipIds");
77     WriteInt(context, *size);
78     WriteEnd(context);
79     if (RpcClientCall(client, "GetWifiChipIds") != WIFI_HAL_OPT_OK) {
80         return WIFI_HAL_OPT_FAILED;
81     }
82     int result = WIFI_HAL_OPT_FAILED;
83     ReadInt(context, &result);
84     if (result != WIFI_HAL_OPT_OK) {
85         LOGE("server GetWifiChipIds deal failed!");
86     } else {
87         ReadInt(context, size);
88         if (*size > WIFI_MAX_CHIP_IDS) {
89             LOGE("GetWifiChipIds fail, size error: %{public}d", *size);
90             return WIFI_HAL_OPT_FAILED;
91         }
92         for (int i = 0; i < *size; ++i) {
93             ReadInt(context, (int *)(ids + i));
94         }
95     }
96     ReadClientEnd(client);
97     UnlockRpcClient(client);
98     return result;
99 }
100 
Start(void)101 WifiErrorNo Start(void)
102 {
103     RpcClient *client = GetStaRpcClient();
104     LockRpcClient(client);
105     Context *context = client->context;
106     WriteBegin(context, 0);
107     WriteFunc(context, "Start");
108     WriteEnd(context);
109     if (RpcClientCall(client, "Start") != WIFI_HAL_OPT_OK) {
110         return WIFI_HAL_OPT_FAILED;
111     }
112     int result = WIFI_HAL_OPT_FAILED;
113     ReadInt(context, &result);
114     ReadClientEnd(client);
115     UnlockRpcClient(client);
116     return result;
117 }
118 
Stop(void)119 WifiErrorNo Stop(void)
120 {
121     RpcClient *client = GetStaRpcClient();
122     LockRpcClient(client);
123     Context *context = client->context;
124     WriteBegin(context, 0);
125     WriteFunc(context, "Stop");
126     WriteEnd(context);
127     if (RpcClientCall(client, "Stop") != WIFI_HAL_OPT_OK) {
128         return WIFI_HAL_OPT_FAILED;
129     }
130     int result = WIFI_HAL_OPT_FAILED;
131     ReadInt(context, &result);
132     ReadClientEnd(client);
133     UnlockRpcClient(client);
134     return result;
135 }
136 
NotifyClear(void)137 WifiErrorNo NotifyClear(void)
138 {
139     RpcClient *client = GetStaRpcClient();
140     LockRpcClient(client);
141     Context *context = client->context;
142     WriteBegin(context, 0);
143     WriteFunc(context, "NotifyClear");
144     WriteEnd(context);
145     if (RpcClientCall(client, "NotifyClear") != WIFI_HAL_OPT_OK) {
146         return WIFI_HAL_OPT_FAILED;
147     }
148     int result = WIFI_HAL_OPT_FAILED;
149     ReadInt(context, &result);
150     ReadClientEnd(client);
151     UnlockRpcClient(client);
152     return result;
153 }
154 
155 /* Defines the callback processing function. */
IdlCbkAddRemoveIface(Context * context,int event)156 static void IdlCbkAddRemoveIface(Context *context, int event)
157 {
158     int type = 0;
159     if (ReadInt(context, &type) < 0) {
160         return;
161     }
162     char *iface = NULL;
163     int len = ReadStr(context, iface, 0);
164     if (len < 0 || len > WIFI_INTERFACE_NAME_SIZE) {
165         return;
166     }
167     iface = (char *)calloc(len + 1, sizeof(char));
168     if (iface == NULL) {
169         return;
170     }
171     if (ReadStr(context, iface, len + 1) < 0) {
172         free(iface);
173         iface = NULL;
174         return;
175     }
176     IWifiChipEventCallback *callback = GetWifiChipEventCallback();
177     if (callback != NULL) {
178         if (event == HAL_CBK_CMD_ADD_IFACE && callback->onIfaceAdded != NULL) {
179             callback->onIfaceAdded(type, iface);
180         } else if (event == HAL_CBK_CMD_REMOVE_IFACE && callback->onIfaceRemoved != NULL) {
181             callback->onIfaceRemoved(type, iface);
182         }
183     }
184     free(iface);
185     iface = NULL;
186     return;
187 }
188 
IdlCbkStaJoinLeave(Context * context)189 static void IdlCbkStaJoinLeave(Context *context)
190 {
191     int id;
192     CStationInfo info = {0};
193     char *reason = NULL;
194     if (ReadInt(context, &id) < 0) {
195         return;
196     }
197     if (ReadInt(context, &info.type) < 0) {
198         return;
199     }
200     int len = ReadStr(context, reason, 0);
201     if (len < 0 || len > WIFI_REASON_LENGTH) {
202         return;
203     }
204     reason = (char *)calloc(len + 1, sizeof(char));
205     if (reason == NULL) {
206         return;
207     }
208     if (ReadStr(context, reason, len + 1) < 0) {
209         free(reason);
210         reason = NULL;
211         return;
212     }
213     if (strncpy_s(info.mac, sizeof(info.mac), reason, sizeof(info.mac) - 1) != EOK) {
214         free(reason);
215         reason = NULL;
216         return;
217     }
218     IWifiApEventCallback *callback = GetWifiApEventCallback(id);
219     if (callback != NULL && callback->onStaJoinOrLeave != NULL) {
220         callback->onStaJoinOrLeave(&info, id);
221     }
222     free(reason);
223     reason = NULL;
224     return;
225 }
226 
IdlCbkScanInfoNotify(Context * context)227 static void IdlCbkScanInfoNotify(Context *context)
228 {
229     int result = 0;
230     if (ReadInt(context, &result) < 0) {
231         return;
232     }
233     ISupplicantEventCallback *callback = GetSupplicantEventCallback();
234     if (callback != NULL && callback->onScanNotify != NULL) {
235         callback->onScanNotify(result);
236     }
237     return;
238 }
239 
IdlCbkConnectChanged(Context * context)240 static void IdlCbkConnectChanged(Context *context)
241 {
242     int status = 0;
243     int networkId = 0;
244     char pMac[WIFI_BSSID_LENGTH] = {0};
245     if (ReadInt(context, &status) < 0 || ReadInt(context, &networkId) < 0 ||
246         ReadStr(context, pMac, sizeof(pMac)) != 0) {
247         return;
248     }
249     IWifiEventCallback *callback = GetWifiEventCallback();
250     if (callback != NULL && callback->onConnectChanged != NULL) {
251         callback->onConnectChanged(status, networkId, pMac);
252     }
253     return;
254 }
255 
IdlCbkDisConnectReasonNotify(Context * context)256 static void IdlCbkDisConnectReasonNotify(Context *context)
257 {
258     int reason = 0;
259     char bssid[WIFI_BSSID_LENGTH] = {0};
260     if (ReadInt(context, &reason) < 0 ||
261         ReadStr(context, bssid, sizeof(bssid)) != 0) {
262         return;
263     }
264     IWifiEventCallback *callback = GetWifiEventCallback();
265     if (callback != NULL && callback->onDisConnectReasonNotify != NULL) {
266         callback->onDisConnectReasonNotify(reason, bssid);
267     }
268     return;
269 }
270 
IdlCbkBssidChanged(Context * context)271 static void IdlCbkBssidChanged(Context *context)
272 {
273     char reason[WIFI_REASON_LENGTH] = {0};
274     char bssid[WIFI_BSSID_LENGTH] = {0};
275     if (ReadStr(context, reason, sizeof(reason)) != 0 ||
276         ReadStr(context, bssid, sizeof(bssid)) != 0) {
277         LOGE("Read event info error!");
278         return;
279     }
280     IWifiEventCallback *callback = GetWifiEventCallback();
281     if (callback != NULL && callback->onBssidChanged != NULL) {
282         callback->onBssidChanged(reason, bssid);
283     }
284     return;
285 }
286 
IdlCbkApStateChange(Context * context,int event)287 static void IdlCbkApStateChange(Context *context, int event)
288 {
289     int id = 0;
290     if (ReadInt(context, &id) < 0) {
291         return;
292     }
293     IWifiApEventCallback *callback = GetWifiApEventCallback(id);
294     if (callback != NULL && callback->onApEnableOrDisable != NULL) {
295         callback->onApEnableOrDisable(event, id);
296     }
297     return;
298 }
299 
IdlCbkWpaEventDeal(Context * context,int event)300 static void IdlCbkWpaEventDeal(Context *context, int event)
301 {
302     int status = 0;
303     if (ReadInt(context, &status) < 0) {
304         return;
305     }
306     IWifiEventCallback *callback = GetWifiEventCallback();
307     if (callback == NULL) {
308         return;
309     }
310     if (event == HAL_CBK_CMD_WPS_TIME_OUT && callback->onWpsTimeOut != NULL) {
311         callback->onWpsTimeOut(status);
312     }
313     if (event == HAL_CBK_CMD_WPS_OVERLAP && callback->onWpsOverlap != NULL) {
314         callback->onWpsOverlap(status);
315     }
316     if (event == HAL_CBK_CMD_SSID_WRONG_KEY && callback->onSsidWrongkey != NULL) {
317         callback->onSsidWrongkey();
318     }
319     if (event == HAL_CBK_CMD_WPA_STATE_CHANGEM && callback->onWpaStateChanged != NULL) {
320         callback->onWpaStateChanged(status);
321     }
322     if (event == HAL_CBK_CMD_WPS_CONNECTION_FULL && callback->onWpsConnectionFull != NULL) {
323         callback->onWpsConnectionFull(status);
324     }
325     if (event == HAL_CBK_CMD_WPS_CONNECTION_REJECT && callback->onWpsConnectionReject != NULL) {
326         callback->onWpsConnectionReject(status);
327     }
328     return;
329 }
330 
IdlDealStaApEvent(Context * context,int event)331 static int IdlDealStaApEvent(Context *context, int event)
332 {
333     LOGI("OnTransact deal sta/ap event: %{public}d", event);
334     switch (event) {
335         case HAL_CBK_CMD_FAILURE:
336         case HAL_CBK_CMD_STARTED:
337         case HAL_CBK_CMD_STOPED:
338             break;
339         case HAL_CBK_CMD_ADD_IFACE:
340         case HAL_CBK_CMD_REMOVE_IFACE:
341             IdlCbkAddRemoveIface(context, event);
342             break;
343         case HAL_CBK_CMD_STA_JOIN:
344         case HAL_CBK_CMD_STA_LEAVE:
345             IdlCbkStaJoinLeave(context);
346             break;
347         case HAL_CBK_CMD_SCAN_INFO_NOTIFY:
348             IdlCbkScanInfoNotify(context);
349             break;
350         case HAL_CBK_CMD_CONNECT_CHANGED:
351             IdlCbkConnectChanged(context);
352             break;
353         case HAL_CBK_CMD_STA_DISCONNECT_REASON_EVENT:
354             IdlCbkDisConnectReasonNotify(context);
355             break;
356         case HAL_CBK_CMD_BSSID_CHANGED:
357             IdlCbkBssidChanged(context);
358             break;
359         case HAL_CBK_CMD_AP_ENABLE:
360         case HAL_CBK_CMD_AP_DISABLE:
361         case HAL_CBK_CMD_AP_STA_PSK_MISMATCH_EVENT:
362             IdlCbkApStateChange(context, event);
363             break;
364         case HAL_CBK_CMD_WPA_STATE_CHANGEM:
365         case HAL_CBK_CMD_SSID_WRONG_KEY:
366         case HAL_CBK_CMD_WPS_OVERLAP:
367         case HAL_CBK_CMD_WPS_TIME_OUT:
368         case HAL_CBK_CMD_WPS_CONNECTION_FULL:
369         case HAL_CBK_CMD_WPS_CONNECTION_REJECT:
370             IdlCbkWpaEventDeal(context, event);
371             break;
372         default:
373             return -1;
374     }
375     return 0;
376 }
377 
IdlCbP2pEventDeal(Context * context)378 static void IdlCbP2pEventDeal(Context *context)
379 {
380     int status = 0;
381     if (ReadInt(context, &status) < 0) {
382         return;
383     }
384     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
385     if (callback != NULL && callback->onP2pSupplicantConnect != NULL) {
386         callback->onP2pSupplicantConnect(status);
387     }
388     return;
389 }
390 
IdlCbP2pSupConnFailedEvent()391 static void IdlCbP2pSupConnFailedEvent()
392 {
393     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
394     if (callback != NULL && callback->connectSupplicantFailed != NULL) {
395         callback->connectSupplicantFailed();
396     }
397     return;
398 }
399 
IdlCbP2pDeviceFoundEventDeal(Context * context)400 static void IdlCbP2pDeviceFoundEventDeal(Context *context)
401 {
402     P2pDeviceInfo info;
403     if (memset_s(&info, sizeof(info), 0, sizeof(info)) != EOK) {
404         return;
405     }
406     if (ReadInt(context, (int *)&info.configMethods) < 0 || ReadInt(context, &info.deviceCapabilities) < 0 ||
407         ReadInt(context, &info.groupCapabilities) < 0 || ReadInt(context, (int *)&info.wfdLength) < 0 ||
408         ReadStr(context, info.srcAddress, sizeof(info.srcAddress)) != 0 ||
409         ReadStr(context, info.p2pDeviceAddress, sizeof(info.p2pDeviceAddress)) != 0 ||
410         ReadStr(context, info.primaryDeviceType, sizeof(info.primaryDeviceType)) != 0 ||
411         ReadStr(context, info.deviceName, sizeof(info.deviceName)) != 0 ||
412         ReadStr(context, info.wfdDeviceInfo, sizeof(info.wfdDeviceInfo)) != 0) {
413         return;
414     }
415     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
416     if (callback != NULL && callback->onDeviceFound != NULL) {
417         callback->onDeviceFound(&info);
418     }
419     return;
420 }
421 
IdlCbP2pDeviceLostEventDeal(Context * context)422 static void IdlCbP2pDeviceLostEventDeal(Context *context)
423 {
424     char address[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
425     if (ReadStr(context, address, sizeof(address)) != 0) {
426         return;
427     }
428     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
429     if (callback != NULL && callback->onDeviceLost != NULL) {
430         callback->onDeviceLost(address);
431     }
432     return;
433 }
434 
IdlCbP2pGoNegotiationRequestEvent(Context * context)435 static void IdlCbP2pGoNegotiationRequestEvent(Context *context)
436 {
437     char address[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
438     int passId = 0;
439     if (ReadInt(context, &passId) < 0 || ReadStr(context, address, sizeof(address)) != 0) {
440         return;
441     }
442     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
443     if (callback != NULL && callback->onGoNegotiationRequest != NULL) {
444         callback->onGoNegotiationRequest(address, passId);
445     }
446     return;
447 }
448 
IdlCbP2pGoNegotiationSuccessEvent()449 static void IdlCbP2pGoNegotiationSuccessEvent()
450 {
451     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
452     if (callback != NULL && callback->onGoNegotiationSuccess != NULL) {
453         callback->onGoNegotiationSuccess();
454     }
455     return;
456 }
457 
IdlCbP2pGoNegotiationFailureEvent(Context * context)458 static void IdlCbP2pGoNegotiationFailureEvent(Context *context)
459 {
460     int status = 0;
461     if (ReadInt(context, &status) < 0) {
462         return;
463     }
464     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
465     if (callback != NULL && callback->onGoNegotiationFailure != NULL) {
466         callback->onGoNegotiationFailure(status);
467     }
468     return;
469 }
470 
IdlCbP2pInvitationReceivedEvent(Context * context)471 static void IdlCbP2pInvitationReceivedEvent(Context *context)
472 {
473     P2pInvitationInfo info;
474     if (memset_s(&info, sizeof(info), 0, sizeof(info)) != EOK) {
475         return;
476     }
477     if (ReadInt(context, &info.type) < 0 || ReadInt(context, &info.persistentNetworkId) < 0 ||
478         ReadInt(context, &info.operatingFrequency) < 0 ||
479         ReadStr(context, info.srcAddress, sizeof(info.srcAddress)) != 0 ||
480         ReadStr(context, info.goDeviceAddress, sizeof(info.goDeviceAddress)) != 0 ||
481         ReadStr(context, info.bssid, sizeof(info.bssid)) != 0) {
482         return;
483     }
484     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
485     if (callback != NULL && callback->onInvitationReceived != NULL) {
486         callback->onInvitationReceived(&info);
487     }
488     return;
489 }
490 
IdlCbP2pInvitationResultEvent(Context * context)491 static void IdlCbP2pInvitationResultEvent(Context *context)
492 {
493     int status = 0;
494     char address[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
495     if (ReadInt(context, &status) < 0 || ReadStr(context, address, sizeof(address)) != 0) {
496         return;
497     }
498     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
499     if (callback != NULL && callback->onInvitationResult != NULL) {
500         callback->onInvitationResult(address, status);
501     }
502     return;
503 }
504 
IdlCbP2pGroupFormationSuccessEvent()505 static void IdlCbP2pGroupFormationSuccessEvent()
506 {
507     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
508     if (callback != NULL && callback->onGroupFormationSuccess != NULL) {
509         callback->onGroupFormationSuccess();
510     }
511     return;
512 }
513 
IdlCbP2pGroupFormationFailureEvent(Context * context)514 static void IdlCbP2pGroupFormationFailureEvent(Context *context)
515 {
516     char reason[WIFI_P2P_TMP_MSG_LENGTH_128] = {0};
517     if (ReadStr(context, reason, sizeof(reason)) != 0) {
518         return;
519     }
520     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
521     if (callback != NULL && callback->onGroupFormationFailure != NULL) {
522         callback->onGroupFormationFailure(reason);
523     }
524     return;
525 }
526 
IdlCbP2pGroupStartedEvent(Context * context)527 static void IdlCbP2pGroupStartedEvent(Context *context)
528 {
529     P2pGroupInfo info;
530     if (memset_s(&info, sizeof(info), 0, sizeof(info)) != EOK) {
531         return;
532     }
533     if (ReadInt(context, &info.isGo) < 0 || ReadInt(context, &info.isPersistent) < 0 ||
534         ReadInt(context, &info.frequency) < 0 || ReadStr(context, info.groupName, sizeof(info.groupName)) != 0 ||
535         ReadStr(context, info.ssid, sizeof(info.ssid)) != 0 || ReadStr(context, info.psk, sizeof(info.psk)) != 0 ||
536         ReadStr(context, info.passphrase, sizeof(info.passphrase)) != 0 ||
537         ReadStr(context, info.goDeviceAddress, sizeof(info.goDeviceAddress)) != 0) {
538         return;
539     }
540     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
541     if (callback != NULL && callback->onGroupStarted != NULL) {
542         callback->onGroupStarted(&info);
543     }
544     return;
545 }
546 
IdlCbP2pGroupRemovedEvent(Context * context)547 static void IdlCbP2pGroupRemovedEvent(Context *context)
548 {
549     int isGo = 0;
550     char groupName[WIFI_P2P_MAX_GROUP_IFACE_NAME_LENGTH] = {0};
551     if (ReadInt(context, &isGo) < 0 || ReadStr(context, groupName, sizeof(groupName)) != 0) {
552         return;
553     }
554     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
555     if (callback != NULL && callback->onGroupRemoved != NULL) {
556         callback->onGroupRemoved(groupName, isGo);
557     }
558     return;
559 }
560 
IdlCbP2pProvDiscEvent(Context * context,int event)561 static void IdlCbP2pProvDiscEvent(Context *context, int event)
562 {
563     char address[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
564     if (ReadStr(context, address, sizeof(address)) != 0) {
565         return;
566     }
567     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
568     if (callback == NULL) {
569         return;
570     }
571     if (event == HAL_CBK_CMD_P2P_PROV_DISC_PBC_REQ_EVENT && callback->onProvisionDiscoveryPbcRequest != NULL) {
572         callback->onProvisionDiscoveryPbcRequest(address);
573     }
574     if (event == HAL_CBK_CMD_P2P_PROV_DISC_PBC_RSP_EVENT && callback->onProvisionDiscoveryPbcResponse != NULL) {
575         callback->onProvisionDiscoveryPbcResponse(address);
576     }
577     if (event == HAL_CBK_CMD_P2P_PROV_DISC_ENTER_PIN_EVENT && callback->onProvisionDiscoveryEnterPin != NULL) {
578         callback->onProvisionDiscoveryEnterPin(address);
579     }
580     return;
581 }
582 
IdlCbP2pProDiscShowPinEvent(Context * context)583 static void IdlCbP2pProDiscShowPinEvent(Context *context)
584 {
585     char address[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
586     char pin[WIFI_PIN_CODE_LENGTH + 1] = {0};
587     if (ReadStr(context, address, sizeof(address)) != 0 || ReadStr(context, pin, sizeof(pin)) != 0) {
588         return;
589     }
590     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
591     if (callback != NULL && callback->onProvisionDiscoveryShowPin != NULL) {
592         callback->onProvisionDiscoveryShowPin(address, pin);
593     }
594     return;
595 }
596 
IdlCbP2pFindStopEvent()597 static void IdlCbP2pFindStopEvent()
598 {
599     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
600     if (callback != NULL && callback->onFindStopped != NULL) {
601         callback->onFindStopped();
602     }
603     return;
604 }
605 
NumStrToNumArry(unsigned char * src,int * size)606 static int NumStrToNumArry(unsigned char *src, int *size)
607 {
608     if (src == NULL || size == NULL) {
609         return -1;
610     }
611     if (*size < 0 || ((unsigned)*size & 1) != 0) {
612         return -1;
613     }
614     const int base = 10;
615     const int shiftNum = 4;
616     int len = *size;
617     int pos = 0;
618     for (int i = 0; i < len; ++i) {
619         unsigned char c = src[i];
620         unsigned char n;
621         if (c >= '0' && c <= '9') {
622             n = c - '0';
623         } else if (c >= 'A' && c <= 'F') {
624             n = c - 'A' + base;
625         } else if (c >= 'a' && c <= 'f') {
626             n = c - 'a' + base;
627         } else {
628             return -1;
629         }
630         if ((i & 0x1) == 0) {
631             src[pos] = n;
632         } else {
633             src[pos] <<= shiftNum;
634             src[pos] |= n;
635             ++pos;
636         }
637     }
638     src[pos] = 0;
639     *size = pos;
640     return 0;
641 }
642 
IdlCbP2pServDiscRespEvent(Context * context)643 static void IdlCbP2pServDiscRespEvent(Context *context)
644 {
645     int updataIndicator = 0;
646     char address[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
647     int tlvsLength = 0;
648     if (ReadInt(context, &updataIndicator) < 0 || ReadStr(context, address, sizeof(address)) != 0 ||
649         ReadInt(context, &tlvsLength) < 0) {
650         return;
651     }
652     unsigned char *tlvs = NULL;
653     if (tlvsLength > 0 && tlvsLength < WIFI_MAX_TLVS_LENGTH) {
654         tlvs = (unsigned char *)calloc(tlvsLength + 1, sizeof(unsigned char));
655         if (tlvs == NULL) {
656             return;
657         }
658         if (ReadStr(context, (char *)tlvs, tlvsLength + 1) != 0) {
659             free(tlvs);
660             tlvs = NULL;
661             return;
662         }
663         if (NumStrToNumArry(tlvs, &tlvsLength) < 0) {
664             LOGE("Failed to convert tlvs hex string to byte list.");
665             free(tlvs);
666             tlvs = NULL;
667             return;
668         }
669     }
670     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
671     if (callback != NULL && callback->onServiceDiscoveryResponse != NULL) {
672         callback->onServiceDiscoveryResponse(address, updataIndicator, tlvs, tlvsLength);
673     }
674     free(tlvs);
675     tlvs = NULL;
676     return;
677 }
678 
IdlCbP2pProvServDiscFailureEvent()679 static void IdlCbP2pProvServDiscFailureEvent()
680 {
681     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
682     if (callback != NULL && callback->onProvisionDiscoveryFailure != NULL) {
683         callback->onProvisionDiscoveryFailure();
684     }
685     return;
686 }
687 
IdlCbP2pApStaConnectEvent(Context * context,int event)688 static void IdlCbP2pApStaConnectEvent(Context *context, int event)
689 {
690     char address[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
691     if (ReadStr(context, address, sizeof(address)) != 0) {
692         return;
693     }
694     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
695     if (callback == NULL) {
696         return;
697     }
698     if (event == HAL_CBK_CMD_AP_STA_DISCONNECTED_EVENT && callback->onStaDeauthorized != NULL) {
699         callback->onStaDeauthorized(address);
700     }
701     if (event == HAL_CBK_CMD_AP_STA_CONNECTED_EVENT && callback->onStaAuthorized != NULL) {
702         callback->onStaAuthorized(address, "");
703     }
704     return;
705 }
706 
IdlCbP2pServDiscReqEvent(Context * context)707 static void IdlCbP2pServDiscReqEvent(Context *context)
708 {
709     P2pServDiscReqInfo info;
710     if (memset_s(&info, sizeof(info), 0, sizeof(info)) != EOK) {
711         return;
712     }
713     if (ReadInt(context, &info.freq) < 0 || ReadInt(context, &info.dialogToken) < 0 ||
714         ReadInt(context, &info.updateIndic) < 0 || ReadStr(context, info.mac, sizeof(info.mac)) != 0 ||
715         ReadInt(context, &info.tlvsLength) < 0) {
716         return;
717     }
718     if (info.tlvsLength > 0 && info.tlvsLength < WIFI_MAX_TLVS_LENGTH) {
719         info.tlvs = (unsigned char *)calloc(info.tlvsLength + 1, sizeof(unsigned char));
720         if (info.tlvs == NULL) {
721             return;
722         }
723         ReadStr(context, (char *)info.tlvs, info.tlvsLength + 1);
724         if (NumStrToNumArry(info.tlvs, &info.tlvsLength) < 0) {
725             LOGE("Failed to convert tlvs hex string to byte list.");
726             free(info.tlvs);
727             info.tlvs = NULL;
728             return;
729         }
730     }
731     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
732     if (callback != NULL && callback->onP2pServDiscReq != NULL) {
733         callback->onP2pServDiscReq(&info);
734     }
735     free(info.tlvs);
736     info.tlvs = NULL;
737     return;
738 }
739 
IdlCbP2pIfaceCreatedEvent(Context * context)740 static void IdlCbP2pIfaceCreatedEvent(Context *context)
741 {
742     int id;
743     int isGo = 0;
744     char ifName[WIFI_INTERFACE_NAME_SIZE] = {0};
745     if (ReadInt(context, &id) < 0 || ReadInt(context, &isGo) < 0 ||
746         ReadStr(context, ifName, sizeof(ifName)) != 0) {
747         LOGE("Failed to read P2pIfaceCreatedEvent id:%{public}d", id);
748         return;
749     }
750     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
751     if (callback != NULL && callback->onP2pIfaceCreated != NULL) {
752         callback->onP2pIfaceCreated(ifName, isGo);
753     }
754 }
755 
IdlCbP2pConnectFailedEvent(Context * context)756 static void IdlCbP2pConnectFailedEvent(Context *context)
757 {
758     int reason = 0;
759     char macAddress[WIFI_MAX_MAC_ADDR_LENGTH + 1] = {0};
760     if (ReadInt(context, &reason) < 0 || ReadStr(context, macAddress, sizeof(macAddress)) != 0) {
761         LOGE("Failed to read P2pConnectFailedEvent");
762         return;
763     }
764     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
765     if (callback != NULL && callback->onP2pConnectFailed != NULL) {
766         callback->onP2pConnectFailed(macAddress, reason);
767     }
768     return;
769 }
770 
IdlCbP2pChannelSwitchEvent(Context * context)771 static void IdlCbP2pChannelSwitchEvent(Context *context)
772 {
773     int freq = 0;
774     if (ReadInt(context, &freq) < 0) {
775         LOGE("Failed to read P2pChannelSwitchEvent");
776         return;
777     }
778     IWifiEventP2pCallback *callback = GetWifiP2pEventCallback();
779     if (callback != NULL && callback->onP2pChannelSwitch != NULL) {
780         callback->onP2pChannelSwitch(freq);
781     }
782     return;
783 }
784 
IdlDealP2pEventFirst(Context * context,int event)785 static int IdlDealP2pEventFirst(Context *context, int event)
786 {
787     switch (event) {
788         case HAL_CBK_CMD_P2P_SUPPLICANT_CONNECT:
789             IdlCbP2pEventDeal(context);
790             break;
791         case HAL_CBK_CMD_SUP_CONN_FAILED_EVENT:
792             IdlCbP2pSupConnFailedEvent();
793             break;
794         case HAL_CBK_CMD_P2P_DEVICE_FOUND_EVENT:
795             IdlCbP2pDeviceFoundEventDeal(context);
796             break;
797         case HAL_CBK_CMD_P2P_DEVICE_LOST_EVENT:
798             IdlCbP2pDeviceLostEventDeal(context);
799             break;
800         case HAL_CBK_CMD_P2P_GO_NEGOTIATION_REQUEST_EVENT:
801             IdlCbP2pGoNegotiationRequestEvent(context);
802             break;
803         case HAL_CBK_CMD_P2P_GO_NEGOTIATION_SUCCESS_EVENT:
804             IdlCbP2pGoNegotiationSuccessEvent();
805             break;
806         case HAL_CBK_CMD_P2P_GO_NEGOTIATION_FAILURE_EVENT:
807             IdlCbP2pGoNegotiationFailureEvent(context);
808             break;
809         case HAL_CBK_CMD_P2P_INVITATION_RECEIVED_EVENT:
810             IdlCbP2pInvitationReceivedEvent(context);
811             break;
812         case HAL_CBK_CMD_P2P_INVITATION_RESULT_EVENT:
813             IdlCbP2pInvitationResultEvent(context);
814             break;
815         case HAL_CBK_CMD_P2P_GROUP_FORMATION_SUCCESS_EVENT:
816             IdlCbP2pGroupFormationSuccessEvent();
817             break;
818         case HAL_CBK_CMD_P2P_GROUP_FORMATION_FAILURE_EVENT:
819             IdlCbP2pGroupFormationFailureEvent(context);
820             break;
821         case HAL_CBK_CMD_P2P_GROUP_STARTED_EVENT:
822             IdlCbP2pGroupStartedEvent(context);
823             break;
824         case HAL_CBK_CMD_P2P_GROUP_REMOVED_EVENT:
825             IdlCbP2pGroupRemovedEvent(context);
826             break;
827         default:
828             return -1;
829     }
830     return 0;
831 }
832 
IdlDealP2pEventSecond(Context * context,int event)833 static int IdlDealP2pEventSecond(Context *context, int event)
834 {
835     switch (event) {
836         case HAL_CBK_CMD_P2P_PROV_DISC_PBC_REQ_EVENT:
837         case HAL_CBK_CMD_P2P_PROV_DISC_PBC_RSP_EVENT:
838         case HAL_CBK_CMD_P2P_PROV_DISC_ENTER_PIN_EVENT:
839             IdlCbP2pProvDiscEvent(context, event);
840             break;
841         case HAL_CBK_CMD_P2P_PROV_DISC_SHOW_PIN_EVENT:
842             IdlCbP2pProDiscShowPinEvent(context);
843             break;
844         case HAL_CBK_CMD_P2P_FIND_STOPPED_EVENT:
845             IdlCbP2pFindStopEvent();
846             break;
847         case HAL_CBK_CMD_P2P_SERV_DISC_RESP_EVENT:
848             IdlCbP2pServDiscRespEvent(context);
849             break;
850         case HAL_CBK_CMD_P2P_PROV_DISC_FAILURE_EVENT:
851             IdlCbP2pProvServDiscFailureEvent();
852             break;
853         case HAL_CBK_CMD_AP_STA_DISCONNECTED_EVENT:
854         case HAL_CBK_CMD_AP_STA_CONNECTED_EVENT:
855             IdlCbP2pApStaConnectEvent(context, event);
856             break;
857         case HAL_CBK_CMD_P2P_SERV_DISC_REQ_EVENT:
858             IdlCbP2pServDiscReqEvent(context);
859             break;
860         case HAL_CBK_CMD_P2P_IFACE_CREATED_EVENT:
861             IdlCbP2pIfaceCreatedEvent(context);
862             break;
863         case HAL_CBK_CMD_P2P_CONNECT_FAILED:
864             IdlCbP2pConnectFailedEvent(context);
865             break;
866         case HAL_CBK_CMD_P2P_CHANNEL_SWITCH_EVENT:
867             IdlCbP2pChannelSwitchEvent(context);
868             break;
869         default:
870             return -1;
871     }
872     return 0;
873 }
874 
IdlDealP2pEvent(Context * context,int event)875 static int IdlDealP2pEvent(Context *context, int event)
876 {
877     LOGI("OnTransact deal p2p event: %{public}d", event);
878     if (IdlDealP2pEventFirst(context, event) == 0 || IdlDealP2pEventSecond(context, event) == 0) {
879         return 0;
880     }
881     return -1;
882 }
883 
OnTransact(Context * context)884 int OnTransact(Context *context)
885 {
886     int event = 0;
887     if (ReadInt(context, &event) < 0) {
888         LOGE("OnTransact read event failed!");
889         return -1;
890     }
891     if (IdlDealStaApEvent(context, event) < 0 && IdlDealP2pEvent(context, event) < 0) {
892         LOGI("unsupported call back events: %{public}d", event);
893     }
894     return 0;
895 }
896