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_p2p_iface.h"
17 #include <securec.h>
18 #include <stdlib.h>
19 #include "client.h"
20 #include "context.h"
21 #include "i_wifi_public_func.h"
22 #include "serial.h"
23 #include "wifi_idl_inner_interface.h"
24 #include "wifi_log.h"
25 #include "wifi_native_define.h"
26 
27 #undef LOG_TAG
28 #define LOG_TAG "WifiIdlP2pIface"
29 
30 #define P2P_EVENT_MAX_NUM 32
31 #define INFO_NUM_MAX 4096
32 
33 static IWifiEventP2pCallback g_wifiP2pEventCallback = {0};
SetWifiP2pEventCallback(IWifiEventP2pCallback callback)34 void SetWifiP2pEventCallback(IWifiEventP2pCallback callback)
35 {
36     g_wifiP2pEventCallback = callback;
37 }
38 
GetWifiP2pEventCallback(void)39 IWifiEventP2pCallback *GetWifiP2pEventCallback(void)
40 {
41     return &g_wifiP2pEventCallback;
42 }
43 
P2pStart(void)44 WifiErrorNo P2pStart(void)
45 {
46     RpcClient *client = GetP2pRpcClient();
47     LockRpcClient(client);
48     Context *context = client->context;
49     WriteBegin(context, 0);
50     WriteFunc(context, "P2pStart");
51     WriteEnd(context);
52     if (RpcClientCall(client, "P2pStart") != WIFI_HAL_OPT_OK) {
53         return WIFI_HAL_OPT_FAILED;
54     }
55     int result = WIFI_HAL_OPT_FAILED;
56     ReadInt(context, &result);
57     ReadClientEnd(client);
58     UnlockRpcClient(client);
59     return result;
60 }
61 
P2pStop(void)62 WifiErrorNo P2pStop(void)
63 {
64     RpcClient *client = GetP2pRpcClient();
65     LockRpcClient(client);
66     Context *context = client->context;
67     WriteBegin(context, 0);
68     WriteFunc(context, "P2pStop");
69     WriteEnd(context);
70     if (RpcClientCall(client, "P2pStop") != WIFI_HAL_OPT_OK) {
71         return WIFI_HAL_OPT_FAILED;
72     }
73     int result = WIFI_HAL_OPT_FAILED;
74     ReadInt(context, &result);
75     ReadClientEnd(client);
76     UnlockRpcClient(client);
77     return result;
78 }
79 
P2pSetRandomMac(int enable)80 WifiErrorNo P2pSetRandomMac(int enable)
81 {
82     RpcClient *client = GetP2pRpcClient();
83     LockRpcClient(client);
84     Context *context = client->context;
85     WriteBegin(context, 0);
86     WriteFunc(context, "P2pSetRandomMac");
87     WriteInt(context, enable);
88     WriteEnd(context);
89     if (RpcClientCall(client, "P2pSetRandomMac") != WIFI_HAL_OPT_OK) {
90         return WIFI_HAL_OPT_FAILED;
91     }
92     int result = WIFI_HAL_OPT_FAILED;
93     ReadInt(context, &result);
94     ReadClientEnd(client);
95     UnlockRpcClient(client);
96     return result;
97 }
98 
P2pSetDeviceName(const char * name)99 WifiErrorNo P2pSetDeviceName(const char *name)
100 {
101     RpcClient *client = GetP2pRpcClient();
102     LockRpcClient(client);
103     Context *context = client->context;
104     WriteBegin(context, 0);
105     WriteFunc(context, "P2pSetDeviceName");
106     WriteStr(context, name);
107     WriteEnd(context);
108     if (RpcClientCall(client, "P2pSetDeviceName") != WIFI_HAL_OPT_OK) {
109         return WIFI_HAL_OPT_FAILED;
110     }
111     int result = WIFI_HAL_OPT_FAILED;
112     ReadInt(context, &result);
113     ReadClientEnd(client);
114     UnlockRpcClient(client);
115     return result;
116 }
117 
P2pSetSsidPostfixName(const char * postfixName)118 WifiErrorNo P2pSetSsidPostfixName(const char *postfixName)
119 {
120     RpcClient *client = GetP2pRpcClient();
121     LockRpcClient(client);
122     Context *context = client->context;
123     WriteBegin(context, 0);
124     WriteFunc(context, "P2pSetSsidPostfixName");
125     WriteStr(context, postfixName);
126     WriteEnd(context);
127     if (RpcClientCall(client, "P2pSetSsidPostfixName") != 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 
P2pSetWpsDeviceType(const char * type)137 WifiErrorNo P2pSetWpsDeviceType(const char *type)
138 {
139     RpcClient *client = GetP2pRpcClient();
140     LockRpcClient(client);
141     Context *context = client->context;
142     WriteBegin(context, 0);
143     WriteFunc(context, "P2pSetWpsDeviceType");
144     WriteStr(context, type);
145     WriteEnd(context);
146     if (RpcClientCall(client, "P2pSetWpsDeviceType") != WIFI_HAL_OPT_OK) {
147         return WIFI_HAL_OPT_FAILED;
148     }
149     int result = WIFI_HAL_OPT_FAILED;
150     ReadInt(context, &result);
151     ReadClientEnd(client);
152     UnlockRpcClient(client);
153     return result;
154 }
155 
P2pSetWpsSecondaryDeviceType(const char * type)156 WifiErrorNo P2pSetWpsSecondaryDeviceType(const char *type)
157 {
158     RpcClient *client = GetP2pRpcClient();
159     LockRpcClient(client);
160     Context *context = client->context;
161     WriteBegin(context, 0);
162     WriteFunc(context, "P2pSetWpsSecondaryDeviceType");
163     WriteStr(context, type);
164     WriteEnd(context);
165     if (RpcClientCall(client, "P2pSetWpsSecondaryDeviceType") != WIFI_HAL_OPT_OK) {
166         return WIFI_HAL_OPT_FAILED;
167     }
168     int result = WIFI_HAL_OPT_FAILED;
169     ReadInt(context, &result);
170     ReadClientEnd(client);
171     UnlockRpcClient(client);
172     return result;
173 }
174 
P2pSetWpsConfigMethods(const char * config)175 WifiErrorNo P2pSetWpsConfigMethods(const char *config)
176 {
177     RpcClient *client = GetP2pRpcClient();
178     LockRpcClient(client);
179     Context *context = client->context;
180     WriteBegin(context, 0);
181     WriteFunc(context, "P2pSetWpsConfigMethods");
182     WriteStr(context, config);
183     WriteEnd(context);
184     if (RpcClientCall(client, "P2pSetWpsConfigMethods") != WIFI_HAL_OPT_OK) {
185         return WIFI_HAL_OPT_FAILED;
186     }
187     int result = WIFI_HAL_OPT_FAILED;
188     ReadInt(context, &result);
189     ReadClientEnd(client);
190     UnlockRpcClient(client);
191     return result;
192 }
193 
P2pGetDeviceAddress(char * deviceAddress,int size)194 WifiErrorNo P2pGetDeviceAddress(char *deviceAddress, int size)
195 {
196     RpcClient *client = GetP2pRpcClient();
197     LockRpcClient(client);
198     Context *context = client->context;
199     WriteBegin(context, 0);
200     WriteFunc(context, "P2pGetDeviceAddress");
201     WriteInt(context, size);
202     WriteEnd(context);
203     if (RpcClientCall(client, "P2pGetDeviceAddress") != WIFI_HAL_OPT_OK) {
204         return WIFI_HAL_OPT_FAILED;
205     }
206     int result = WIFI_HAL_OPT_FAILED;
207     ReadInt(context, &result);
208     if (result != WIFI_HAL_OPT_OK) {
209         LOGE("P2pGetDeviceAddress failed!");
210     } else {
211         ReadStr(context, deviceAddress, size);
212     }
213     ReadClientEnd(client);
214     UnlockRpcClient(client);
215     return result;
216 }
217 
P2pFlush()218 WifiErrorNo P2pFlush()
219 {
220     RpcClient *client = GetP2pRpcClient();
221     LockRpcClient(client);
222     Context *context = client->context;
223     WriteBegin(context, 0);
224     WriteFunc(context, "P2pFlush");
225     WriteEnd(context);
226     if (RpcClientCall(client, "P2pFlush") != WIFI_HAL_OPT_OK) {
227         return WIFI_HAL_OPT_FAILED;
228     }
229     int result = WIFI_HAL_OPT_FAILED;
230     ReadInt(context, &result);
231     ReadClientEnd(client);
232     UnlockRpcClient(client);
233     return result;
234 }
235 
P2pFlushService()236 WifiErrorNo P2pFlushService()
237 {
238     RpcClient *client = GetP2pRpcClient();
239     LockRpcClient(client);
240     Context *context = client->context;
241     WriteBegin(context, 0);
242     WriteFunc(context, "P2pFlushService");
243     WriteEnd(context);
244     if (RpcClientCall(client, "P2pFlushService") != WIFI_HAL_OPT_OK) {
245         return WIFI_HAL_OPT_FAILED;
246     }
247     int result = WIFI_HAL_OPT_FAILED;
248     ReadInt(context, &result);
249     ReadClientEnd(client);
250     UnlockRpcClient(client);
251     return result;
252 }
253 
P2pSaveConfig()254 WifiErrorNo P2pSaveConfig()
255 {
256     RpcClient *client = GetP2pRpcClient();
257     LockRpcClient(client);
258     Context *context = client->context;
259     WriteBegin(context, 0);
260     WriteFunc(context, "P2pSaveConfig");
261     WriteEnd(context);
262     if (RpcClientCall(client, "P2pSaveConfig") != WIFI_HAL_OPT_OK) {
263         return WIFI_HAL_OPT_FAILED;
264     }
265     int result = WIFI_HAL_OPT_FAILED;
266     ReadInt(context, &result);
267     ReadClientEnd(client);
268     UnlockRpcClient(client);
269     return result;
270 }
271 
GetP2pCallbackEvents(int * events,int size)272 static int GetP2pCallbackEvents(int *events, int size)
273 {
274     int p2pEvents[] = {
275         HAL_CBK_CMD_P2P_SUPPLICANT_CONNECT,
276         HAL_CBK_CMD_P2P_DEVICE_FOUND_EVENT,
277         HAL_CBK_CMD_P2P_DEVICE_LOST_EVENT,
278         HAL_CBK_CMD_P2P_GO_NEGOTIATION_REQUEST_EVENT,
279         HAL_CBK_CMD_P2P_GO_NEGOTIATION_SUCCESS_EVENT,
280         HAL_CBK_CMD_P2P_GO_NEGOTIATION_FAILURE_EVENT,
281         HAL_CBK_CMD_P2P_INVITATION_RECEIVED_EVENT,
282         HAL_CBK_CMD_P2P_INVITATION_RESULT_EVENT,
283         HAL_CBK_CMD_P2P_GROUP_FORMATION_SUCCESS_EVENT,
284         HAL_CBK_CMD_P2P_GROUP_FORMATION_FAILURE_EVENT,
285         HAL_CBK_CMD_P2P_GROUP_STARTED_EVENT,
286         HAL_CBK_CMD_P2P_GROUP_REMOVED_EVENT,
287         HAL_CBK_CMD_P2P_PROV_DISC_PBC_REQ_EVENT,
288         HAL_CBK_CMD_P2P_PROV_DISC_PBC_RSP_EVENT,
289         HAL_CBK_CMD_P2P_PROV_DISC_ENTER_PIN_EVENT,
290         HAL_CBK_CMD_P2P_PROV_DISC_SHOW_PIN_EVENT,
291         HAL_CBK_CMD_P2P_PROV_DISC_FAILURE_EVENT,
292         HAL_CBK_CMD_P2P_FIND_STOPPED_EVENT,
293         HAL_CBK_CMD_P2P_SERV_DISC_RESP_EVENT,
294         HAL_CBK_CMD_AP_STA_DISCONNECTED_EVENT,
295         HAL_CBK_CMD_AP_STA_CONNECTED_EVENT,
296         HAL_CBK_CMD_SUP_CONN_FAILED_EVENT,
297         HAL_CBK_CMD_P2P_SERV_DISC_REQ_EVENT,
298         HAL_CBK_CMD_P2P_IFACE_CREATED_EVENT,
299         HAL_CBK_CMD_P2P_CONNECT_FAILED,
300         HAL_CBK_CMD_P2P_CHANNEL_SWITCH_EVENT
301     };
302     int max = sizeof(p2pEvents) / sizeof(p2pEvents[0]);
303     int num = 0;
304     for (; num < max && num < size; ++num) {
305         events[num] = p2pEvents[num];
306     }
307     return num;
308 }
309 
RegisterP2pEventCallback(IWifiEventP2pCallback callback)310 WifiErrorNo RegisterP2pEventCallback(IWifiEventP2pCallback callback)
311 {
312     int events[P2P_EVENT_MAX_NUM];
313     int num = GetP2pCallbackEvents(events, P2P_EVENT_MAX_NUM);
314     RpcClient *client = GetP2pRpcClient();
315     LockRpcClient(client);
316     Context *context = client->context;
317     WriteBegin(context, 0);
318     if (callback.onP2pSupplicantConnect == NULL) { /* UnRegisterEventCallback */
319         WriteFunc(context, "UnRegisterEventCallback");
320     } else {
321         WriteFunc(context, "RegisterEventCallback");
322     }
323     WriteInt(context, num);
324     for (int i = 0; i < num; ++i) {
325         WriteInt(context, events[i]);
326     }
327     WriteEnd(context);
328     if (RpcClientCall(client, "RegisterP2pEventCallback") != WIFI_HAL_OPT_OK) {
329         if (callback.onP2pSupplicantConnect == NULL) {
330             SetWifiP2pEventCallback(callback);
331         }
332         return WIFI_HAL_OPT_FAILED;
333     }
334     int result = WIFI_HAL_OPT_FAILED;
335     ReadInt(context, &result);
336     if (result == WIFI_HAL_OPT_OK || callback.onP2pSupplicantConnect == NULL) {
337         SetWifiP2pEventCallback(callback);
338     }
339     ReadClientEnd(client);
340     UnlockRpcClient(client);
341     return result;
342 }
343 
P2pSetupWpsPbc(const char * groupIfc,const char * address)344 WifiErrorNo P2pSetupWpsPbc(const char *groupIfc, const char *address)
345 {
346     RpcClient *client = GetP2pRpcClient();
347     LockRpcClient(client);
348     Context *context = client->context;
349     WriteBegin(context, 0);
350     WriteFunc(context, "P2pSetupWpsPbc");
351     WriteStr(context, groupIfc);
352     WriteStr(context, address);
353     WriteEnd(context);
354     if (RpcClientCall(client, "P2pSetupWpsPbc") != WIFI_HAL_OPT_OK) {
355         return WIFI_HAL_OPT_FAILED;
356     }
357     int result = WIFI_HAL_OPT_FAILED;
358     ReadInt(context, &result);
359     ReadClientEnd(client);
360     UnlockRpcClient(client);
361     return result;
362 }
363 
P2pSetupWpsPin(const char * groupIfc,const char * address,const char * pin,char * result,int resultLen)364 WifiErrorNo P2pSetupWpsPin(const char *groupIfc, const char *address, const char *pin, char *result, int resultLen)
365 {
366     RpcClient *client = GetP2pRpcClient();
367     LockRpcClient(client);
368     Context *context = client->context;
369     WriteBegin(context, 0);
370     WriteFunc(context, "P2pSetupWpsPin");
371     WriteStr(context, groupIfc);
372     WriteStr(context, address);
373     WriteStr(context, pin);
374     WriteInt(context, resultLen);
375     WriteEnd(context);
376     if (RpcClientCall(client, "P2pSetupWpsPin") != WIFI_HAL_OPT_OK) {
377         return WIFI_HAL_OPT_FAILED;
378     }
379     int retCode = WIFI_HAL_OPT_FAILED;
380     ReadInt(context, &retCode);
381     if (retCode == WIFI_HAL_OPT_OK) {
382         ReadStr(context, result, resultLen);
383     }
384     ReadClientEnd(client);
385     UnlockRpcClient(client);
386     return retCode;
387 }
388 
P2pRemoveNetwork(int networkId)389 WifiErrorNo P2pRemoveNetwork(int networkId)
390 {
391     RpcClient *client = GetP2pRpcClient();
392     LockRpcClient(client);
393     Context *context = client->context;
394     WriteBegin(context, 0);
395     WriteFunc(context, "P2pRemoveNetwork");
396     WriteInt(context, networkId);
397     WriteEnd(context);
398     if (RpcClientCall(client, "P2pRemoveNetwork") != WIFI_HAL_OPT_OK) {
399         return WIFI_HAL_OPT_FAILED;
400     }
401     int result = WIFI_HAL_OPT_FAILED;
402     ReadInt(context, &result);
403     ReadClientEnd(client);
404     UnlockRpcClient(client);
405     return result;
406 }
407 
P2pListNetworks(P2pNetworkList * infoList)408 WifiErrorNo P2pListNetworks(P2pNetworkList *infoList)
409 {
410     RpcClient *client = GetP2pRpcClient();
411     LockRpcClient(client);
412     Context *context = client->context;
413     WriteBegin(context, 0);
414     WriteFunc(context, "P2pListNetworks");
415     WriteEnd(context);
416     if (RpcClientCall(client, "P2pListNetworks") != WIFI_HAL_OPT_OK) {
417         return WIFI_HAL_OPT_FAILED;
418     }
419     int result = WIFI_HAL_OPT_FAILED;
420     ReadInt(context, &result);
421     do {
422         if (result != WIFI_HAL_OPT_OK) {
423             LOGE("P2pListNetworks failed!");
424             break;
425         }
426         int infoNum = 0;
427         ReadInt(context, &infoNum);
428         infoList->infoNum = infoNum;
429         if (infoNum <= 0 || infoNum > INFO_NUM_MAX) {
430             break;
431         }
432         infoList->infos = (P2pNetworkInfo *)calloc(infoNum, sizeof(P2pNetworkInfo));
433         if (infoList->infos == NULL) {
434             result = WIFI_HAL_OPT_FAILED;
435             break;
436         }
437         for (int i = 0; i < infoNum; i++) {
438             ReadInt(context, &infoList->infos[i].id);
439             ReadStr(context, infoList->infos[i].ssid, sizeof(infoList->infos[i].ssid));
440             ReadStr(context, infoList->infos[i].bssid, sizeof(infoList->infos[i].bssid));
441             ReadStr(context, infoList->infos[i].flags, sizeof(infoList->infos[i].flags));
442         }
443     } while (0);
444     ReadClientEnd(client);
445     UnlockRpcClient(client);
446     return result;
447 }
448 
P2pSetGroupMaxIdle(const char * groupIfc,int time)449 WifiErrorNo P2pSetGroupMaxIdle(const char *groupIfc, int time)
450 {
451     RpcClient *client = GetP2pRpcClient();
452     LockRpcClient(client);
453     Context *context = client->context;
454     WriteBegin(context, 0);
455     WriteFunc(context, "P2pSetGroupMaxIdle");
456     WriteStr(context, groupIfc);
457     WriteInt(context, time);
458     WriteEnd(context);
459     if (RpcClientCall(client, "P2pSetGroupMaxIdle") != WIFI_HAL_OPT_OK) {
460         return WIFI_HAL_OPT_FAILED;
461     }
462     int result = WIFI_HAL_OPT_FAILED;
463     ReadInt(context, &result);
464     ReadClientEnd(client);
465     UnlockRpcClient(client);
466     return result;
467 }
468 
P2pSetPowerSave(const char * groupIfc,int enable)469 WifiErrorNo P2pSetPowerSave(const char *groupIfc, int enable)
470 {
471     RpcClient *client = GetP2pRpcClient();
472     LockRpcClient(client);
473     Context *context = client->context;
474     WriteBegin(context, 0);
475     WriteFunc(context, "P2pSetPowerSave");
476     WriteStr(context, groupIfc);
477     WriteInt(context, enable);
478     WriteEnd(context);
479     if (RpcClientCall(client, "P2pSetPowerSave") != WIFI_HAL_OPT_OK) {
480         return WIFI_HAL_OPT_FAILED;
481     }
482     int result = WIFI_HAL_OPT_FAILED;
483     ReadInt(context, &result);
484     ReadClientEnd(client);
485     UnlockRpcClient(client);
486     return result;
487 }
488 
P2pSetWfdEnable(int enable)489 WifiErrorNo P2pSetWfdEnable(int enable)
490 {
491     RpcClient *client = GetP2pRpcClient();
492     LockRpcClient(client);
493     Context *context = client->context;
494     WriteBegin(context, 0);
495     WriteFunc(context, "P2pSetWfdEnable");
496     WriteInt(context, enable);
497     WriteEnd(context);
498     if (RpcClientCall(client, "P2pSetWfdEnable") != WIFI_HAL_OPT_OK) {
499         return WIFI_HAL_OPT_FAILED;
500     }
501     int result = WIFI_HAL_OPT_FAILED;
502     ReadInt(context, &result);
503     ReadClientEnd(client);
504     UnlockRpcClient(client);
505     return result;
506 }
507 
P2pSetWfdDeviceConfig(const char * config)508 WifiErrorNo P2pSetWfdDeviceConfig(const char *config)
509 {
510     RpcClient *client = GetP2pRpcClient();
511     LockRpcClient(client);
512     Context *context = client->context;
513     WriteBegin(context, 0);
514     WriteFunc(context, "P2pSetWfdDeviceConfig");
515     WriteStr(context, config);
516     WriteEnd(context);
517     if (RpcClientCall(client, "P2pSetWfdDeviceConfig") != WIFI_HAL_OPT_OK) {
518         return WIFI_HAL_OPT_FAILED;
519     }
520     int result = WIFI_HAL_OPT_FAILED;
521     ReadInt(context, &result);
522     ReadClientEnd(client);
523     UnlockRpcClient(client);
524     return result;
525 }
526 
P2pStartFind(int timeout)527 WifiErrorNo P2pStartFind(int timeout)
528 {
529     RpcClient *client = GetP2pRpcClient();
530     LockRpcClient(client);
531     Context *context = client->context;
532     WriteBegin(context, 0);
533     WriteFunc(context, "P2pStartFind");
534     WriteInt(context, timeout);
535     WriteEnd(context);
536     if (RpcClientCall(client, "P2pStartFind") != WIFI_HAL_OPT_OK) {
537         return WIFI_HAL_OPT_FAILED;
538     }
539     int result = WIFI_HAL_OPT_FAILED;
540     ReadInt(context, &result);
541     ReadClientEnd(client);
542     UnlockRpcClient(client);
543     return result;
544 }
545 
P2pStopFind()546 WifiErrorNo P2pStopFind()
547 {
548     RpcClient *client = GetP2pRpcClient();
549     LockRpcClient(client);
550     Context *context = client->context;
551     WriteBegin(context, 0);
552     WriteFunc(context, "P2pStopFind");
553     WriteEnd(context);
554     if (RpcClientCall(client, "P2pStopFind") != WIFI_HAL_OPT_OK) {
555         return WIFI_HAL_OPT_FAILED;
556     }
557     int result = WIFI_HAL_OPT_FAILED;
558     ReadInt(context, &result);
559     ReadClientEnd(client);
560     UnlockRpcClient(client);
561     return result;
562 }
563 
P2pSetExtListen(int enable,int period,int interval)564 WifiErrorNo P2pSetExtListen(int enable, int period, int interval)
565 {
566     RpcClient *client = GetP2pRpcClient();
567     LockRpcClient(client);
568     Context *context = client->context;
569     WriteBegin(context, 0);
570     WriteFunc(context, "P2pSetExtListen");
571     WriteInt(context, enable);
572     WriteInt(context, period);
573     WriteInt(context, interval);
574     WriteEnd(context);
575     if (RpcClientCall(client, "P2pSetExtListen") != WIFI_HAL_OPT_OK) {
576         return WIFI_HAL_OPT_FAILED;
577     }
578     int result = WIFI_HAL_OPT_FAILED;
579     ReadInt(context, &result);
580     ReadClientEnd(client);
581     UnlockRpcClient(client);
582     return result;
583 }
584 
P2pSetListenChannel(int channel,int regClass)585 WifiErrorNo P2pSetListenChannel(int channel, int regClass)
586 {
587     RpcClient *client = GetP2pRpcClient();
588     LockRpcClient(client);
589     Context *context = client->context;
590     WriteBegin(context, 0);
591     WriteFunc(context, "P2pSetListenChannel");
592     WriteInt(context, channel);
593     WriteInt(context, regClass);
594     WriteEnd(context);
595     if (RpcClientCall(client, "P2pSetListenChannel") != WIFI_HAL_OPT_OK) {
596         return WIFI_HAL_OPT_FAILED;
597     }
598     int result = WIFI_HAL_OPT_FAILED;
599     ReadInt(context, &result);
600     ReadClientEnd(client);
601     UnlockRpcClient(client);
602     return result;
603 }
604 
P2pConnect(P2pConnectInfo * info)605 WifiErrorNo P2pConnect(P2pConnectInfo *info)
606 {
607     RpcClient *client = GetP2pRpcClient();
608     LockRpcClient(client);
609     Context *context = client->context;
610     WriteBegin(context, 0);
611     WriteFunc(context, "P2pConnect");
612     WriteInt(context, info->mode);
613     WriteInt(context, info->provdisc);
614     WriteInt(context, info->goIntent);
615     WriteInt(context, info->persistent);
616     WriteStr(context, info->peerDevAddr);
617     WriteStr(context, info->pin);
618     WriteEnd(context);
619     if (RpcClientCall(client, "P2pConnect") != WIFI_HAL_OPT_OK) {
620         return WIFI_HAL_OPT_FAILED;
621     }
622     int result = WIFI_HAL_OPT_FAILED;
623     ReadInt(context, &result);
624     if (result == WIFI_HAL_OPT_OK) {
625         if (memset_s(info->pin, sizeof(info->pin), 0, sizeof(info->pin)) != EOK) {
626             result = WIFI_HAL_OPT_FAILED;
627         } else {
628             ReadStr(context, info->pin, sizeof(info->pin));
629         }
630     }
631     ReadClientEnd(client);
632     UnlockRpcClient(client);
633     return result;
634 }
635 
P2pCancelConnect()636 WifiErrorNo P2pCancelConnect()
637 {
638     RpcClient *client = GetP2pRpcClient();
639     LockRpcClient(client);
640     Context *context = client->context;
641     WriteBegin(context, 0);
642     WriteFunc(context, "P2pCancelConnect");
643     WriteEnd(context);
644     if (RpcClientCall(client, "P2pCancelConnect") != WIFI_HAL_OPT_OK) {
645         return WIFI_HAL_OPT_FAILED;
646     }
647     int result = WIFI_HAL_OPT_FAILED;
648     ReadInt(context, &result);
649     ReadClientEnd(client);
650     UnlockRpcClient(client);
651     return result;
652 }
653 
P2pProvisionDiscovery(const char * peerBssid,int mode)654 WifiErrorNo P2pProvisionDiscovery(const char *peerBssid, int mode)
655 {
656     LOGD("P2pProvisionDiscovery addr: %{private}s, mode: %{public}d", peerBssid, mode);
657     RpcClient *client = GetP2pRpcClient();
658     LockRpcClient(client);
659     Context *context = client->context;
660     WriteBegin(context, 0);
661     WriteFunc(context, "P2pProvisionDiscovery");
662     WriteStr(context, peerBssid);
663     WriteInt(context, mode);
664     WriteEnd(context);
665     if (RpcClientCall(client, "P2pProvisionDiscovery") != WIFI_HAL_OPT_OK) {
666         return WIFI_HAL_OPT_FAILED;
667     }
668     int result = WIFI_HAL_OPT_FAILED;
669     ReadInt(context, &result);
670     ReadClientEnd(client);
671     UnlockRpcClient(client);
672     return result;
673 }
674 
P2pAddGroup(int isPersistent,int networkId,int freq)675 WifiErrorNo P2pAddGroup(int isPersistent, int networkId, int freq)
676 {
677     RpcClient *client = GetP2pRpcClient();
678     LockRpcClient(client);
679     Context *context = client->context;
680     WriteBegin(context, 0);
681     WriteFunc(context, "P2pAddGroup");
682     WriteInt(context, isPersistent);
683     WriteInt(context, networkId);
684     WriteInt(context, freq);
685     WriteEnd(context);
686     if (RpcClientCall(client, "P2pAddGroup") != WIFI_HAL_OPT_OK) {
687         return WIFI_HAL_OPT_FAILED;
688     }
689     int result = WIFI_HAL_OPT_FAILED;
690     ReadInt(context, &result);
691     ReadClientEnd(client);
692     UnlockRpcClient(client);
693     return result;
694 }
695 
P2pRemoveGroup(const char * interface)696 WifiErrorNo P2pRemoveGroup(const char *interface)
697 {
698     RpcClient *client = GetP2pRpcClient();
699     LockRpcClient(client);
700     Context *context = client->context;
701     WriteBegin(context, 0);
702     WriteFunc(context, "P2pRemoveGroup");
703     WriteStr(context, interface);
704     WriteEnd(context);
705     if (RpcClientCall(client, "P2pRemoveGroup") != WIFI_HAL_OPT_OK) {
706         return WIFI_HAL_OPT_FAILED;
707     }
708     int result = WIFI_HAL_OPT_FAILED;
709     ReadInt(context, &result);
710     ReadClientEnd(client);
711     UnlockRpcClient(client);
712     return result;
713 }
714 
P2pRemoveGroupClient(const char * deviceMac)715 WifiErrorNo P2pRemoveGroupClient(const char *deviceMac)
716 {
717     RpcClient *client = GetP2pRpcClient();
718     LockRpcClient(client);
719     Context *context = client->context;
720     WriteBegin(context, 0);
721     WriteFunc(context, "P2pRemoveGroupClient");
722     WriteStr(context, deviceMac);
723     WriteEnd(context);
724     if (RpcClientCall(client, "P2pRemoveGroupClient") != WIFI_HAL_OPT_OK) {
725         return WIFI_HAL_OPT_FAILED;
726     }
727     int result = WIFI_HAL_OPT_FAILED;
728     ReadInt(context, &result);
729     ReadClientEnd(client);
730     UnlockRpcClient(client);
731     return result;
732 }
733 
P2pInvite(int persisitent,const char * peerBssid,const char * goBssid,const char * ifname)734 WifiErrorNo P2pInvite(int persisitent, const char *peerBssid, const char *goBssid, const char *ifname)
735 {
736     RpcClient *client = GetP2pRpcClient();
737     LockRpcClient(client);
738     Context *context = client->context;
739     WriteBegin(context, 0);
740     WriteFunc(context, "P2pInvite");
741     WriteInt(context, persisitent);
742     WriteStr(context, peerBssid);
743     WriteStr(context, goBssid);
744     WriteStr(context, ifname);
745     WriteEnd(context);
746     if (RpcClientCall(client, "P2pInvite") != WIFI_HAL_OPT_OK) {
747         return WIFI_HAL_OPT_FAILED;
748     }
749     int result = WIFI_HAL_OPT_FAILED;
750     ReadInt(context, &result);
751     ReadClientEnd(client);
752     UnlockRpcClient(client);
753     return result;
754 }
755 
P2pReinvoke(int networkId,const char * bssid)756 WifiErrorNo P2pReinvoke(int networkId, const char *bssid)
757 {
758     RpcClient *client = GetP2pRpcClient();
759     LockRpcClient(client);
760     Context *context = client->context;
761     WriteBegin(context, 0);
762     WriteFunc(context, "P2pReinvoke");
763     WriteInt(context, networkId);
764     WriteStr(context, bssid);
765     WriteEnd(context);
766     if (RpcClientCall(client, "P2pReinvoke") != WIFI_HAL_OPT_OK) {
767         return WIFI_HAL_OPT_FAILED;
768     }
769     int result = WIFI_HAL_OPT_FAILED;
770     ReadInt(context, &result);
771     ReadClientEnd(client);
772     UnlockRpcClient(client);
773     return result;
774 }
775 
P2pGetGroupCapability(const char * bssid,int * cap)776 WifiErrorNo P2pGetGroupCapability(const char *bssid, int *cap)
777 {
778     RpcClient *client = GetP2pRpcClient();
779     LockRpcClient(client);
780     Context *context = client->context;
781     WriteBegin(context, 0);
782     WriteFunc(context, "P2pGetGroupCapability");
783     WriteStr(context, bssid);
784     WriteEnd(context);
785     if (RpcClientCall(client, "P2pGetGroupCapability") != WIFI_HAL_OPT_OK) {
786         return WIFI_HAL_OPT_FAILED;
787     }
788     int result = WIFI_HAL_OPT_FAILED;
789     ReadInt(context, &result);
790     if (result != WIFI_HAL_OPT_OK) {
791         LOGE("P2pGetGroupCapability failed!");
792     } else {
793         ReadInt(context, cap);
794     }
795     ReadClientEnd(client);
796     UnlockRpcClient(client);
797     return result;
798 }
799 
P2pAddService(const P2pServiceInfo * info)800 WifiErrorNo P2pAddService(const P2pServiceInfo *info)
801 {
802     RpcClient *client = GetP2pRpcClient();
803     LockRpcClient(client);
804     Context *context = client->context;
805     WriteBegin(context, 0);
806     WriteFunc(context, "P2pAddService");
807     WriteInt(context, info->mode);
808     if (!info->mode) {
809         WriteInt(context, info->version);
810         WriteStr(context, info->name);
811     } else {
812         WriteStr(context, info->query);
813         WriteStr(context, info->resp);
814     }
815     WriteEnd(context);
816     if (RpcClientCall(client, "P2pAddService") != WIFI_HAL_OPT_OK) {
817         return WIFI_HAL_OPT_FAILED;
818     }
819     int result = WIFI_HAL_OPT_FAILED;
820     ReadInt(context, &result);
821     ReadClientEnd(client);
822     UnlockRpcClient(client);
823     return result;
824 }
825 
P2pRemoveService(const P2pServiceInfo * info)826 WifiErrorNo P2pRemoveService(const P2pServiceInfo *info)
827 {
828     RpcClient *client = GetP2pRpcClient();
829     LockRpcClient(client);
830     Context *context = client->context;
831     WriteBegin(context, 0);
832     WriteFunc(context, "P2pRemoveService");
833     WriteInt(context, info->mode);
834     if (!info->mode) {
835         WriteInt(context, info->version);
836         WriteStr(context, info->name);
837     } else {
838         WriteStr(context, info->query);
839     }
840     WriteEnd(context);
841     if (RpcClientCall(client, "P2pRemoveService") != WIFI_HAL_OPT_OK) {
842         return WIFI_HAL_OPT_FAILED;
843     }
844     int result = WIFI_HAL_OPT_FAILED;
845     ReadInt(context, &result);
846     ReadClientEnd(client);
847     UnlockRpcClient(client);
848     return result;
849 }
850 
P2pReqServiceDiscovery(const char * bssid,const char * msg,char * retMsg,int size)851 WifiErrorNo P2pReqServiceDiscovery(const char *bssid, const char *msg, char *retMsg, int size)
852 {
853     RpcClient *client = GetP2pRpcClient();
854     LockRpcClient(client);
855     Context *context = client->context;
856     WriteBegin(context, 0);
857     WriteFunc(context, "P2pReqServiceDiscovery");
858     WriteStr(context, bssid);
859     WriteStr(context, msg);
860     WriteInt(context, size);
861     WriteEnd(context);
862     if (RpcClientCall(client, "P2pReqServiceDiscovery") != WIFI_HAL_OPT_OK) {
863         return WIFI_HAL_OPT_FAILED;
864     }
865     int result = WIFI_HAL_OPT_FAILED;
866     ReadInt(context, &result);
867     if (result == WIFI_HAL_OPT_OK) {
868         ReadStr(context, retMsg, size);
869     }
870     ReadClientEnd(client);
871     UnlockRpcClient(client);
872     return result;
873 }
874 
P2pCancelServiceDiscovery(const char * id)875 WifiErrorNo P2pCancelServiceDiscovery(const char *id)
876 {
877     RpcClient *client = GetP2pRpcClient();
878     LockRpcClient(client);
879     Context *context = client->context;
880     WriteBegin(context, 0);
881     WriteFunc(context, "P2pCancelServiceDiscovery");
882     WriteStr(context, id);
883     WriteEnd(context);
884     if (RpcClientCall(client, "P2pCancelServiceDiscovery") != WIFI_HAL_OPT_OK) {
885         return WIFI_HAL_OPT_FAILED;
886     }
887     int result = WIFI_HAL_OPT_FAILED;
888     ReadInt(context, &result);
889     ReadClientEnd(client);
890     UnlockRpcClient(client);
891     return result;
892 }
893 
P2pSetMiracastType(int type)894 WifiErrorNo P2pSetMiracastType(int type)
895 {
896     RpcClient *client = GetP2pRpcClient();
897     LockRpcClient(client);
898     Context *context = client->context;
899     WriteBegin(context, 0);
900     WriteFunc(context, "P2pSetMiracastType");
901     WriteInt(context, type);
902     WriteEnd(context);
903     if (RpcClientCall(client, "P2pSetMiracastType") != WIFI_HAL_OPT_OK) {
904         return WIFI_HAL_OPT_FAILED;
905     }
906     int result = WIFI_HAL_OPT_FAILED;
907     ReadInt(context, &result);
908     ReadClientEnd(client);
909     UnlockRpcClient(client);
910     return result;
911 }
912 
P2pSetPersistentReconnect(int mode)913 WifiErrorNo P2pSetPersistentReconnect(int mode)
914 {
915     RpcClient *client = GetP2pRpcClient();
916     LockRpcClient(client);
917     Context *context = client->context;
918     WriteBegin(context, 0);
919     WriteFunc(context, "P2pSetPersistentReconnect");
920     WriteInt(context, mode);
921     WriteEnd(context);
922     if (RpcClientCall(client, "P2pSetPersistentReconnect") != WIFI_HAL_OPT_OK) {
923         return WIFI_HAL_OPT_FAILED;
924     }
925     int result = WIFI_HAL_OPT_FAILED;
926     ReadInt(context, &result);
927     ReadClientEnd(client);
928     UnlockRpcClient(client);
929     return result;
930 }
931 
P2pRespServerDiscovery(const char * deviceAddress,int frequency,int dialogToken,const char * tlvs)932 WifiErrorNo P2pRespServerDiscovery(const char *deviceAddress, int frequency, int dialogToken, const char *tlvs)
933 {
934     RpcClient *client = GetP2pRpcClient();
935     LockRpcClient(client);
936     Context *context = client->context;
937     WriteBegin(context, 0);
938     WriteFunc(context, "P2pRespServerDiscovery");
939     WriteInt(context, frequency);
940     WriteInt(context, dialogToken);
941     WriteStr(context, deviceAddress);
942     WriteStr(context, tlvs);
943     WriteEnd(context);
944     if (RpcClientCall(client, "P2pRespServerDiscovery") != WIFI_HAL_OPT_OK) {
945         return WIFI_HAL_OPT_FAILED;
946     }
947     int result = WIFI_HAL_OPT_FAILED;
948     ReadInt(context, &result);
949     ReadClientEnd(client);
950     UnlockRpcClient(client);
951     return result;
952 }
953 
P2pSetServDiscExternal(int mode)954 WifiErrorNo P2pSetServDiscExternal(int mode)
955 {
956     RpcClient *client = GetP2pRpcClient();
957     LockRpcClient(client);
958     Context *context = client->context;
959     WriteBegin(context, 0);
960     WriteFunc(context, "P2pSetServDiscExternal");
961     WriteInt(context, mode);
962     WriteEnd(context);
963     if (RpcClientCall(client, "P2pSetServDiscExternal") != WIFI_HAL_OPT_OK) {
964         return WIFI_HAL_OPT_FAILED;
965     }
966     int result = WIFI_HAL_OPT_FAILED;
967     ReadInt(context, &result);
968     ReadClientEnd(client);
969     UnlockRpcClient(client);
970     return result;
971 }
972 
P2pGetPeer(const char * deviceAddress,P2pDeviceInfo * peerInfo)973 WifiErrorNo P2pGetPeer(const char *deviceAddress, P2pDeviceInfo *peerInfo)
974 {
975     RpcClient *client = GetP2pRpcClient();
976     LockRpcClient(client);
977     Context *context = client->context;
978     WriteBegin(context, 0);
979     WriteFunc(context, "P2pGetPeer");
980     WriteStr(context, deviceAddress);
981     WriteEnd(context);
982     if (RpcClientCall(client, "P2pGetPeer") != WIFI_HAL_OPT_OK) {
983         return WIFI_HAL_OPT_FAILED;
984     }
985     int result = WIFI_HAL_OPT_FAILED;
986     ReadInt(context, &result);
987     if (result != WIFI_HAL_OPT_OK) {
988         LOGE("P2pGetPeer failed!");
989     } else {
990         ReadStr(context, peerInfo->p2pDeviceAddress, sizeof(peerInfo->p2pDeviceAddress));
991         ReadStr(context, peerInfo->deviceName, sizeof(peerInfo->deviceName));
992         ReadStr(context, peerInfo->primaryDeviceType, sizeof(peerInfo->primaryDeviceType));
993         ReadInt(context, &peerInfo->configMethods);
994         ReadInt(context, &peerInfo->deviceCapabilities);
995         ReadInt(context, &peerInfo->groupCapabilities);
996         ReadStr(context, peerInfo->operSsid, sizeof(peerInfo->operSsid));
997     }
998     ReadClientEnd(client);
999     UnlockRpcClient(client);
1000     return result;
1001 }
1002 
P2pGetChba0Freq(int * chba0Freq)1003 WifiErrorNo P2pGetChba0Freq(int *chba0Freq)
1004 {
1005     RpcClient *client = GetP2pRpcClient();
1006     LockRpcClient(client);
1007     Context *context = client->context;
1008     WriteBegin(context, 0);
1009     WriteFunc(context, "P2pGetChba0Freq");
1010     WriteEnd(context);
1011     if (RpcClientCall(client, "P2pGetChba0Freq") != WIFI_HAL_OPT_OK) {
1012         return WIFI_HAL_OPT_FAILED;
1013     }
1014     int result = WIFI_HAL_OPT_FAILED;
1015     ReadInt(context, &result);
1016     if (result != WIFI_HAL_OPT_OK) {
1017         LOGE("P2pGetChba0Freq failed!");
1018     } else {
1019         ReadInt(context, chba0Freq);
1020     }
1021     ReadClientEnd(client);
1022     UnlockRpcClient(client);
1023     return result;
1024 }
1025 
P2pGetFrequencies(int32_t band,int * frequencies,int32_t * size)1026 WifiErrorNo P2pGetFrequencies(int32_t band, int *frequencies, int32_t *size)
1027 {
1028     RpcClient *client = GetP2pRpcClient();
1029     LockRpcClient(client);
1030     Context *context = client->context;
1031     WriteBegin(context, 0);
1032     WriteFunc(context, "P2pGetFrequencies");
1033     WriteInt(context, band);
1034     WriteInt(context, *size);
1035     WriteEnd(context);
1036     if (RpcClientCall(client, "P2pGetFrequencies") != WIFI_HAL_OPT_OK) {
1037         return WIFI_HAL_OPT_FAILED;
1038     }
1039 
1040     int result = WIFI_HAL_OPT_FAILED;
1041     ReadInt(context, &result);
1042     if (result != WIFI_HAL_OPT_OK) {
1043         LOGE("server P2pGetFrequencies deal failed!");
1044     } else {
1045         ReadInt(context, size);
1046         for (int i = 0; i < *size; ++i) {
1047             ReadInt(context, frequencies + i);
1048         }
1049     }
1050     ReadClientEnd(client);
1051     UnlockRpcClient(client);
1052     return result;
1053 }
1054 
P2pSetGroupConfig(int networkId,P2pGroupConfig * pConfig,int size)1055 WifiErrorNo P2pSetGroupConfig(int networkId, P2pGroupConfig *pConfig, int size)
1056 {
1057     RpcClient *client = GetP2pRpcClient();
1058     LockRpcClient(client);
1059     Context *context = client->context;
1060     WriteBegin(context, 0);
1061     WriteFunc(context, "P2pSetGroupConfig");
1062     WriteInt(context, networkId);
1063     WriteInt(context, size);
1064     for (int i = 0; i < size; ++i) {
1065         WriteInt(context, pConfig[i].cfgParam);
1066         WriteStr(context, pConfig[i].cfgValue);
1067     }
1068     WriteEnd(context);
1069     if (RpcClientCall(client, "P2pSetGroupConfig") != WIFI_HAL_OPT_OK) {
1070         return WIFI_HAL_OPT_FAILED;
1071     }
1072     int result = WIFI_HAL_OPT_FAILED;
1073     ReadInt(context, &result);
1074     if (result != WIFI_HAL_OPT_OK) {
1075         LOGE("server P2pSetGroupConfig deal failed!");
1076     }
1077     ReadClientEnd(client);
1078     UnlockRpcClient(client);
1079     return result;
1080 }
1081 
P2pGetGroupConfig(int networkId,P2pGroupConfig * pConfig,int size)1082 WifiErrorNo P2pGetGroupConfig(int networkId, P2pGroupConfig *pConfig, int size)
1083 {
1084     RpcClient *client = GetP2pRpcClient();
1085     LockRpcClient(client);
1086     Context *context = client->context;
1087     WriteBegin(context, 0);
1088     WriteFunc(context, "P2pGetGroupConfig");
1089     WriteInt(context, networkId);
1090     WriteInt(context, size);
1091     for (int i = 0; i < size; ++i) {
1092         WriteInt(context, pConfig[i].cfgParam);
1093     }
1094     WriteEnd(context);
1095     if (RpcClientCall(client, "P2pGetGroupConfig") != WIFI_HAL_OPT_OK) {
1096         return WIFI_HAL_OPT_FAILED;
1097     }
1098     int result = WIFI_HAL_OPT_FAILED;
1099     ReadInt(context, &result);
1100     if (result != WIFI_HAL_OPT_OK) {
1101         LOGE("server P2pGetGroupConfig deal failed!");
1102     } else {
1103         for (int i = 0; i < size; i++) {
1104             ReadStr(context, pConfig[i].cfgValue, sizeof(pConfig[i].cfgValue));
1105         }
1106     }
1107     ReadClientEnd(client);
1108     UnlockRpcClient(client);
1109     return result;
1110 }
1111 
P2pAddNetwork(int * networkId)1112 WifiErrorNo P2pAddNetwork(int *networkId)
1113 {
1114     RpcClient *client = GetP2pRpcClient();
1115     LockRpcClient(client);
1116     Context *context = client->context;
1117     WriteBegin(context, 0);
1118     WriteFunc(context, "P2pAddNetwork");
1119     WriteEnd(context);
1120     if (RpcClientCall(client, "P2pAddNetwork") != WIFI_HAL_OPT_OK) {
1121         return WIFI_HAL_OPT_FAILED;
1122     }
1123     int result = WIFI_HAL_OPT_FAILED;
1124     ReadInt(context, &result);
1125     if (result != WIFI_HAL_OPT_OK) {
1126         LOGE("server P2pAddNetwork deal failed!");
1127     } else {
1128         ReadInt(context, networkId);
1129     }
1130     ReadClientEnd(client);
1131     UnlockRpcClient(client);
1132     return result;
1133 }
1134 
Hid2dConnect(Hid2dConnectInfo * info)1135 WifiErrorNo Hid2dConnect(Hid2dConnectInfo *info)
1136 {
1137     RpcClient *client = GetP2pRpcClient();
1138     LockRpcClient(client);
1139     Context *context = client->context;
1140     WriteBegin(context, 0);
1141     WriteFunc(context, "P2pHid2dConnect");
1142     WriteStr(context, info->ssid);
1143     WriteStr(context, info->bssid);
1144     WriteStr(context, info->passphrase);
1145     WriteInt(context, info->frequency);
1146     WriteInt(context, info->isLegacyGo);
1147     WriteEnd(context);
1148     if (RpcClientCall(client, "P2pHid2dConnect") != WIFI_HAL_OPT_OK) {
1149         return WIFI_HAL_OPT_FAILED;
1150     }
1151     int result = WIFI_HAL_OPT_FAILED;
1152     ReadInt(context, &result);
1153     ReadClientEnd(client);
1154     UnlockRpcClient(client);
1155     return result;
1156 }
1157