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_sta_iface.h"
17 #include <stdlib.h>
18 #include <sys/un.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 "WifiIdlStaIface"
29 
30 static int g_staCallbackEvents[] = {
31     HAL_CBK_CMD_FAILURE,
32     HAL_CBK_CMD_STARTED,
33     HAL_CBK_CMD_STOPED,
34     HAL_CBK_CMD_CONNECT_CHANGED,
35     HAL_CBK_CMD_BSSID_CHANGED,
36     HAL_CBK_CMD_WPA_STATE_CHANGEM,
37     HAL_CBK_CMD_SSID_WRONG_KEY,
38     HAL_CBK_CMD_WPS_OVERLAP,
39     HAL_CBK_CMD_WPS_TIME_OUT,
40     HAL_CBK_CMD_WPS_CONNECTION_FULL,
41     HAL_CBK_CMD_WPS_CONNECTION_REJECT,
42     HAL_CBK_CMD_STA_DISCONNECT_REASON_EVENT
43 };
44 
45 static IWifiEventCallback g_wifiStaEventCallback = {0};
SetWifiEventCallback(IWifiEventCallback callback)46 void SetWifiEventCallback(IWifiEventCallback callback)
47 {
48     g_wifiStaEventCallback = callback;
49 }
50 
GetWifiEventCallback(void)51 IWifiEventCallback *GetWifiEventCallback(void)
52 {
53     return &g_wifiStaEventCallback;
54 }
55 
GetStaCapabilities(int32_t * capabilities)56 WifiErrorNo GetStaCapabilities(int32_t *capabilities)
57 {
58     RpcClient *client = GetStaRpcClient();
59     LockRpcClient(client);
60     Context *context = client->context;
61     WriteBegin(context, 0);
62     WriteFunc(context, "GetStaCapabilities");
63     WriteEnd(context);
64     if (RpcClientCall(client, "GetStaCapabilities") != WIFI_HAL_OPT_OK) {
65         return WIFI_HAL_OPT_FAILED;
66     }
67     int result = WIFI_HAL_OPT_FAILED;
68     ReadInt(context, &result);
69     if (result != WIFI_HAL_OPT_OK) {
70         LOGE("server GetStaCapabilities deal failed!");
71     } else {
72         ReadInt(context, capabilities);
73     }
74     ReadClientEnd(client);
75     UnlockRpcClient(client);
76     return result;
77 }
78 
GetDeviceMacAddress(unsigned char * mac,int * lenMac)79 WifiErrorNo GetDeviceMacAddress(unsigned char *mac, int *lenMac)
80 {
81     RpcClient *client = GetStaRpcClient();
82     LockRpcClient(client);
83     Context *context = client->context;
84     WriteBegin(context, 0);
85     WriteFunc(context, "GetDeviceMacAddress");
86     WriteInt(context, *lenMac);
87     WriteEnd(context);
88     if (RpcClientCall(client, "GetDeviceMacAddress") != WIFI_HAL_OPT_OK) {
89         return WIFI_HAL_OPT_FAILED;
90     }
91     int result = WIFI_HAL_OPT_FAILED;
92     ReadInt(context, &result);
93     if (result != WIFI_HAL_OPT_OK) {
94         LOGE("server GetDeviceMacAddress deal failed!");
95     } else {
96         ReadInt(context, lenMac);
97         ReadUStr(context, mac, *lenMac + 1);
98     }
99     ReadClientEnd(client);
100     UnlockRpcClient(client);
101     return result;
102 }
103 
GetFrequencies(int32_t band,int * frequencies,int32_t * size)104 WifiErrorNo GetFrequencies(int32_t band, int *frequencies, int32_t *size)
105 {
106     RpcClient *client = GetStaRpcClient();
107     LockRpcClient(client);
108     Context *context = client->context;
109     WriteBegin(context, 0);
110     WriteFunc(context, "GetFrequencies");
111     WriteInt(context, band);
112     WriteInt(context, *size);
113     WriteEnd(context);
114     if (RpcClientCall(client, "GetFrequencies") != WIFI_HAL_OPT_OK) {
115         return WIFI_HAL_OPT_FAILED;
116     }
117     int result = WIFI_HAL_OPT_FAILED;
118     ReadInt(context, &result);
119     if (result != WIFI_HAL_OPT_OK) {
120         LOGE("server GetFrequencies deal failed!");
121     } else {
122         ReadInt(context, size);
123         for (int i = 0; i < *size; ++i) {
124             ReadInt(context, frequencies + i);
125         }
126     }
127     ReadClientEnd(client);
128     UnlockRpcClient(client);
129     return result;
130 }
131 
SetAssocMacAddr(unsigned char * mac,int lenMac,const int portType)132 WifiErrorNo SetAssocMacAddr(unsigned char *mac, int lenMac, const int portType)
133 {
134     RpcClient *client = GetStaRpcClient();
135     LockRpcClient(client);
136     Context *context = client->context;
137     WriteBegin(context, 0);
138     WriteFunc(context, "SetAssocMacAddr");
139     WriteInt(context, lenMac);
140     WriteUStr(context, mac, lenMac);
141     WriteInt(context, portType);
142     WriteEnd(context);
143     if (RpcClientCall(client, "SetAssocMacAddr") != WIFI_HAL_OPT_OK) {
144         return WIFI_HAL_OPT_FAILED;
145     }
146     int result = WIFI_HAL_OPT_FAILED;
147     ReadInt(context, &result);
148     ReadClientEnd(client);
149     UnlockRpcClient(client);
150     return result;
151 }
152 
SetScanningMacAddress(unsigned char * mac,int lenMac)153 WifiErrorNo SetScanningMacAddress(unsigned char *mac, int lenMac)
154 {
155     RpcClient *client = GetStaRpcClient();
156     LockRpcClient(client);
157     Context *context = client->context;
158     WriteBegin(context, 0);
159     WriteFunc(context, "SetScanningMacAddress");
160     WriteInt(context, lenMac);
161     WriteUStr(context, mac, lenMac);
162     WriteEnd(context);
163     if (RpcClientCall(client, "SetScanningMacAddress") != WIFI_HAL_OPT_OK) {
164         return WIFI_HAL_OPT_FAILED;
165     }
166     int result = WIFI_HAL_OPT_FAILED;
167     ReadInt(context, &result);
168     ReadClientEnd(client);
169     UnlockRpcClient(client);
170     return result;
171 }
172 
DeauthLastRoamingBssid(unsigned char * mac,int lenMac)173 WifiErrorNo DeauthLastRoamingBssid(unsigned char *mac, int lenMac)
174 {
175     RpcClient *client = GetStaRpcClient();
176     LockRpcClient(client);
177     Context *context = client->context;
178     WriteBegin(context, 0);
179     WriteFunc(context, "DeauthLastRoamingBssid");
180     WriteInt(context, lenMac);
181     WriteUStr(context, mac, lenMac);
182     WriteEnd(context);
183     if (RpcClientCall(client, "DeauthLastRoamingBssid") != WIFI_HAL_OPT_OK) {
184         return WIFI_HAL_OPT_FAILED;
185     }
186     int result = WIFI_HAL_OPT_FAILED;
187     ReadInt(context, &result);
188     ReadClientEnd(client);
189     UnlockRpcClient(client);
190     return result;
191 }
192 
GetSupportFeature(long * feature)193 WifiErrorNo GetSupportFeature(long *feature)
194 {
195     RpcClient *client = GetStaRpcClient();
196     LockRpcClient(client);
197     Context *context = client->context;
198     WriteBegin(context, 0);
199     WriteFunc(context, "GetSupportFeature");
200     WriteEnd(context);
201     if (RpcClientCall(client, "GetSupportFeature") != WIFI_HAL_OPT_OK) {
202         return WIFI_HAL_OPT_FAILED;
203     }
204     int result = WIFI_HAL_OPT_FAILED;
205     ReadInt(context, &result);
206     if (result == WIFI_HAL_OPT_OK) {
207         ReadLong(context, feature);
208     }
209     ReadClientEnd(client);
210     UnlockRpcClient(client);
211     return result;
212 }
213 
RunCmd(const char * ifname,int32_t cmdId,unsigned char * buf,int32_t bufSize)214 WifiErrorNo RunCmd(const char *ifname, int32_t cmdId, unsigned char *buf, int32_t bufSize)
215 {
216     RpcClient *client = GetStaRpcClient();
217     LockRpcClient(client);
218     Context *context = client->context;
219     WriteBegin(context, 0);
220     WriteFunc(context, "RunCmd");
221     WriteStr(context, ifname);
222     WriteInt(context, cmdId);
223     WriteInt(context, bufSize);
224     WriteUStr(context, buf, bufSize);
225     WriteEnd(context);
226     if (RpcClientCall(client, "RunCmd") != 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 
SetWifiTxPower(int32_t power)236 WifiErrorNo SetWifiTxPower(int32_t power)
237 {
238     RpcClient *client = GetStaRpcClient();
239     LockRpcClient(client);
240     Context *context = client->context;
241     WriteBegin(context, 0);
242     WriteFunc(context, "SetWifiTxPower");
243     WriteInt(context, power);
244     WriteEnd(context);
245     if (RpcClientCall(client, "SetWifiTxPower") != WIFI_HAL_OPT_OK) {
246         return WIFI_HAL_OPT_FAILED;
247     }
248     int result = WIFI_HAL_OPT_FAILED;
249     ReadInt(context, &result);
250     ReadClientEnd(client);
251     UnlockRpcClient(client);
252     return result;
253 }
254 
RemoveNetwork(int networkId)255 WifiErrorNo RemoveNetwork(int networkId)
256 {
257     RpcClient *client = GetStaRpcClient();
258     LockRpcClient(client);
259     Context *context = client->context;
260     WriteBegin(context, 0);
261     WriteFunc(context, "RemoveNetwork");
262     WriteInt(context, networkId);
263     WriteEnd(context);
264     if (RpcClientCall(client, "RemoveNetwork") != WIFI_HAL_OPT_OK) {
265         return WIFI_HAL_OPT_FAILED;
266     }
267     int result = WIFI_HAL_OPT_FAILED;
268     ReadInt(context, &result);
269     ReadClientEnd(client);
270     UnlockRpcClient(client);
271     return result;
272 }
273 
AddNetwork(int * networkId)274 WifiErrorNo AddNetwork(int *networkId)
275 {
276     RpcClient *client = GetStaRpcClient();
277     LockRpcClient(client);
278     Context *context = client->context;
279     WriteBegin(context, 0);
280     WriteFunc(context, "AddNetwork");
281     WriteEnd(context);
282     if (RpcClientCall(client, "AddNetwork") != WIFI_HAL_OPT_OK) {
283         return WIFI_HAL_OPT_FAILED;
284     }
285     int result = WIFI_HAL_OPT_FAILED;
286     ReadInt(context, &result);
287     if (result != WIFI_HAL_OPT_OK) {
288         LOGE("server AddNetwork deal failed!");
289     } else {
290         ReadInt(context, networkId);
291     }
292     ReadClientEnd(client);
293     UnlockRpcClient(client);
294     return result;
295 }
296 
EnableNetwork(int networkId)297 WifiErrorNo EnableNetwork(int networkId)
298 {
299     RpcClient *client = GetStaRpcClient();
300     LockRpcClient(client);
301     Context *context = client->context;
302     WriteBegin(context, 0);
303     WriteFunc(context, "EnableNetwork");
304     WriteInt(context, networkId);
305     WriteEnd(context);
306     if (RpcClientCall(client, "EnableNetwork") != WIFI_HAL_OPT_OK) {
307         return WIFI_HAL_OPT_FAILED;
308     }
309     int result = WIFI_HAL_OPT_FAILED;
310     ReadInt(context, &result);
311     if (result != WIFI_HAL_OPT_OK) {
312         LOGE("server EnableNetwork deal failed!");
313     }
314     ReadClientEnd(client);
315     UnlockRpcClient(client);
316     return result;
317 }
318 
DisableNetwork(int networkId)319 WifiErrorNo DisableNetwork(int networkId)
320 {
321     RpcClient *client = GetStaRpcClient();
322     LockRpcClient(client);
323     Context *context = client->context;
324     WriteBegin(context, 0);
325     WriteFunc(context, "DisableNetwork");
326     WriteInt(context, networkId);
327     WriteEnd(context);
328     if (RpcClientCall(client, "DisableNetwork") != WIFI_HAL_OPT_OK) {
329         return WIFI_HAL_OPT_FAILED;
330     }
331     int result = WIFI_HAL_OPT_FAILED;
332     ReadInt(context, &result);
333     if (result != WIFI_HAL_OPT_OK) {
334         LOGE("server DisableNetwork deal failed!");
335     }
336     ReadClientEnd(client);
337     UnlockRpcClient(client);
338     return result;
339 }
340 
SetNetwork(int networkId,SetNetworkConfig * confs,int size)341 WifiErrorNo SetNetwork(int networkId, SetNetworkConfig *confs, int size)
342 {
343     RpcClient *client = GetStaRpcClient();
344     LockRpcClient(client);
345     Context *context = client->context;
346     WriteBegin(context, 0);
347     WriteFunc(context, "SetNetwork");
348     WriteInt(context, networkId);
349     WriteInt(context, size);
350     for (int i = 0; i < size; ++i) {
351         WriteInt(context, confs[i].cfgParam);
352         WriteStr(context, confs[i].cfgValue);
353     }
354     WriteEnd(context);
355     if (RpcClientCall(client, "SetNetwork") != WIFI_HAL_OPT_OK) {
356         return WIFI_HAL_OPT_FAILED;
357     }
358     int result = WIFI_HAL_OPT_FAILED;
359     ReadInt(context, &result);
360     if (result != WIFI_HAL_OPT_OK) {
361         LOGE("server SetNetwork deal failed!");
362     }
363     ReadClientEnd(client);
364     UnlockRpcClient(client);
365     return result;
366 }
367 
WpaGetNetwork(GetNetworkConfig * confs)368 WifiErrorNo WpaGetNetwork(GetNetworkConfig *confs)
369 {
370     RpcClient *client = GetStaRpcClient();
371     LockRpcClient(client);
372     Context *context = client->context;
373     WriteBegin(context, 0);
374     WriteFunc(context, "WpaGetNetwork");
375     WriteInt(context, confs->networkId);
376     WriteStr(context, confs->param);
377     WriteEnd(context);
378     if (RpcClientCall(client, "WpaGetNetwork") != WIFI_HAL_OPT_OK) {
379         return WIFI_HAL_OPT_FAILED;
380     }
381     int result = WIFI_HAL_OPT_FAILED;
382     ReadInt(context, &result);
383     if (result != WIFI_HAL_OPT_OK) {
384         LOGE("server WpaGetNetwork deal failed!");
385     } else {
386         ReadStr(context, confs->value, WIFI_NETWORK_CONFIG_VALUE_LENGTH);
387     }
388     ReadClientEnd(client);
389     UnlockRpcClient(client);
390     return (WifiErrorNo)result;
391 }
392 
SaveNetworkConfig(void)393 WifiErrorNo SaveNetworkConfig(void)
394 {
395     RpcClient *client = GetStaRpcClient();
396     LockRpcClient(client);
397     Context *context = client->context;
398     WriteBegin(context, 0);
399     WriteFunc(context, "SaveNetworkConfig");
400     WriteEnd(context);
401     if (RpcClientCall(client, "SaveNetworkConfig") != WIFI_HAL_OPT_OK) {
402         return WIFI_HAL_OPT_FAILED;
403     }
404     int result = WIFI_HAL_OPT_FAILED;
405     ReadInt(context, &result);
406     ReadClientEnd(client);
407     UnlockRpcClient(client);
408     return result;
409 }
410 
StartScan(const ScanSettings * settings)411 WifiErrorNo StartScan(const ScanSettings *settings)
412 {
413     if (settings == NULL) {
414         return WIFI_HAL_OPT_FAILED;
415     }
416     RpcClient *client = GetStaRpcClient();
417     LockRpcClient(client);
418     Context *context = client->context;
419     WriteBegin(context, 0);
420     WriteFunc(context, "StartScan");
421     WriteInt(context, settings->hiddenSsidSize);
422     for (int i = 0; i < settings->hiddenSsidSize; ++i) {
423         WriteInt(context, strlen(settings->hiddenSsid[i]));
424         WriteStr(context, settings->hiddenSsid[i]);
425     }
426     WriteInt(context, settings->freqSize);
427     for (int i = 0; i < settings->freqSize; ++i) {
428         WriteInt(context, settings->freqs[i]);
429     }
430     WriteInt(context, settings->scanStyle);
431     WriteEnd(context);
432     if (RpcClientCall(client, "StartScan") != WIFI_HAL_OPT_OK) {
433         return WIFI_HAL_OPT_FAILED;
434     }
435     int result = WIFI_HAL_OPT_FAILED;
436     ReadInt(context, &result);
437     ReadClientEnd(client);
438     UnlockRpcClient(client);
439     return result;
440 }
441 
GetNetworkList(WifiNetworkInfo * infos,int * size)442 WifiErrorNo GetNetworkList(WifiNetworkInfo *infos, int *size)
443 {
444     RpcClient *client = GetStaRpcClient();
445     LockRpcClient(client);
446     Context *context = client->context;
447     WriteBegin(context, 0);
448     WriteFunc(context, "GetNetworkList");
449     WriteInt(context, *size);
450     WriteEnd(context);
451     if (RpcClientCall(client, "GetNetworkList") != WIFI_HAL_OPT_OK) {
452         return WIFI_HAL_OPT_FAILED;
453     }
454     int result = WIFI_HAL_OPT_FAILED;
455     ReadInt(context, &result);
456     if (result != WIFI_HAL_OPT_OK) {
457         LOGE("server GetNetworkList deal failed!");
458     } else {
459         ReadInt(context, size);
460         for (int i = 0; i < *size; ++i) {
461             ReadInt(context, &infos[i].id);
462             ReadStr(context, infos[i].ssid, WIFI_SSID_LENGTH);
463             ReadStr(context, infos[i].bssid, WIFI_BSSID_LENGTH);
464             ReadStr(context, infos[i].flags, WIFI_NETWORK_FLAGS_LENGTH);
465         }
466     }
467     ReadClientEnd(client);
468     UnlockRpcClient(client);
469     return result;
470 }
471 
GetScanInfoElems(Context * context,ScanInfo * scanInfo)472 static void GetScanInfoElems(Context *context, ScanInfo* scanInfo)
473 {
474     const int MAX_INFO_ELEMS_SIZE = 256;
475     ReadInt(context, &scanInfo->ieSize);
476     if (scanInfo->ieSize <= 0 || scanInfo->ieSize > MAX_INFO_ELEMS_SIZE) {
477         return;
478     }
479     /* This pointer will be released in its client */
480     scanInfo->infoElems = (ScanInfoElem *)calloc(scanInfo->ieSize, sizeof(ScanInfoElem));
481     if (scanInfo->infoElems == NULL) {
482         return;
483     }
484     for (int i = 0; i < scanInfo->ieSize; ++i) {
485         ReadInt(context, (int *)&scanInfo->infoElems[i].id);
486         ReadInt(context, &scanInfo->infoElems[i].size);
487         if (scanInfo->infoElems[i].size <= 0) {
488             continue;
489         }
490         /* This pointer will be released in its client */
491         scanInfo->infoElems[i].content = calloc(scanInfo->infoElems[i].size + 1, sizeof(char));
492         if (scanInfo->infoElems[i].content == NULL) {
493             return;
494         }
495         ReadUStr(context, (unsigned char *)scanInfo->infoElems[i].content,
496             scanInfo->infoElems[i].size + 1);
497     }
498 }
499 
GetScanInfos(int * size)500 ScanInfo* GetScanInfos(int *size)
501 {
502     RpcClient *client = GetStaRpcClient();
503     LockRpcClient(client);
504     Context *context = client->context;
505     WriteBegin(context, 0);
506     WriteFunc(context, "GetScanInfos");
507     WriteInt(context, *size);
508     WriteEnd(context);
509     if (RpcClientCall(client, "GetScanInfos") != WIFI_HAL_OPT_OK) {
510         return NULL;
511     }
512     int result = WIFI_HAL_OPT_FAILED;
513     ScanInfo* scanInfos = NULL;
514     ReadInt(context, &result);
515     if (result != WIFI_HAL_OPT_OK) {
516         LOGE("server GetScanInfos deal failed!");
517     } else {
518         ReadInt(context, size);
519         LOGI("GetScanInfos size: %{public}d", *size);
520         if (*size > 0) {
521             scanInfos = (ScanInfo *)calloc(*size, sizeof(ScanInfo));
522             if (scanInfos != NULL) {
523                 for (int i = 0; i < *size; ++i) {
524                     ReadStr(context, scanInfos[i].bssid, WIFI_BSSID_LENGTH);
525                     ReadInt(context, &scanInfos[i].freq);
526                     ReadInt(context, &scanInfos[i].siglv);
527                     ReadStr(context, scanInfos[i].flags, WIFI_SCAN_INFO_CAPABILITY_LENGTH);
528                     ReadStr(context, scanInfos[i].ssid, WIFI_SSID_LENGTH);
529                     ReadInt64(context, &scanInfos[i].timestamp);
530                     ReadInt(context, &scanInfos[i].channelWidth);
531                     ReadInt(context, &scanInfos[i].centerFrequency0);
532                     ReadInt(context, &scanInfos[i].centerFrequency1);
533                     ReadInt(context, &scanInfos[i].isVhtInfoExist);
534                     ReadInt(context, &scanInfos[i].isHtInfoExist);
535                     ReadInt(context, &scanInfos[i].isHeInfoExist);
536                     ReadInt(context, &scanInfos[i].isErpExist);
537                     ReadInt(context, &scanInfos[i].maxRates);
538                     ReadInt(context, &scanInfos[i].extMaxRates);
539                     GetScanInfoElems(context, &scanInfos[i]);
540                 }
541             } else {
542                 LOGE("GetScanInfos alloc mem failed!");
543             }
544         }
545     }
546     ReadClientEnd(client);
547     UnlockRpcClient(client);
548     return scanInfos;
549 }
550 
StartPnoScan(const PnoScanSettings * settings)551 WifiErrorNo StartPnoScan(const PnoScanSettings *settings)
552 {
553     if (settings == NULL) {
554         return WIFI_HAL_OPT_FAILED;
555     }
556     RpcClient *client = GetStaRpcClient();
557     LockRpcClient(client);
558     Context *context = client->context;
559     WriteBegin(context, 0);
560     WriteFunc(context, "StartPnoScan");
561     WriteInt(context, settings->scanInterval);
562     WriteInt(context, settings->minRssi2Dot4Ghz);
563     WriteInt(context, settings->minRssi5Ghz);
564     WriteInt(context, settings->hiddenSsidSize);
565     for (int i = 0; i < settings->hiddenSsidSize; ++i) {
566         WriteInt(context, strlen(settings->hiddenSsid[i]));
567         WriteStr(context, settings->hiddenSsid[i]);
568     }
569     WriteInt(context, settings->savedSsidSize);
570     for (int i = 0; i < settings->savedSsidSize; ++i) {
571         WriteInt(context, strlen(settings->savedSsid[i]));
572         WriteStr(context, settings->savedSsid[i]);
573     }
574     WriteInt(context, settings->freqSize);
575     for (int i = 0; i < settings->freqSize; ++i) {
576         WriteInt(context, settings->freqs[i]);
577     }
578     WriteEnd(context);
579     if (RpcClientCall(client, "StartPnoScan") != WIFI_HAL_OPT_OK) {
580         return WIFI_HAL_OPT_FAILED;
581     }
582     int result = WIFI_HAL_OPT_FAILED;
583     ReadInt(context, &result);
584     ReadClientEnd(client);
585     UnlockRpcClient(client);
586     return result;
587 }
588 
StopPnoScan(void)589 WifiErrorNo StopPnoScan(void)
590 {
591     RpcClient *client = GetStaRpcClient();
592     LockRpcClient(client);
593     Context *context = client->context;
594     WriteBegin(context, 0);
595     WriteFunc(context, "StopPnoScan");
596     WriteEnd(context);
597     if (RpcClientCall(client, "StopPnoScan") != WIFI_HAL_OPT_OK) {
598         return WIFI_HAL_OPT_FAILED;
599     }
600     int result = WIFI_HAL_OPT_FAILED;
601     ReadInt(context, &result);
602     ReadClientEnd(client);
603     UnlockRpcClient(client);
604     return result;
605 }
606 
RegisterStaEventCallback(IWifiEventCallback callback)607 WifiErrorNo RegisterStaEventCallback(IWifiEventCallback callback)
608 {
609     int num = sizeof(g_staCallbackEvents) / sizeof(g_staCallbackEvents[0]);
610     RpcClient *client = GetStaRpcClient();
611     LockRpcClient(client);
612     Context *context = client->context;
613     WriteBegin(context, 0);
614     if (callback.onConnectChanged == NULL) {
615         WriteFunc(context, "UnRegisterEventCallback");
616     } else {
617         WriteFunc(context, "RegisterEventCallback");
618     }
619     WriteInt(context, num);
620     for (int i = 0; i < num; ++i) {
621         WriteInt(context, g_staCallbackEvents[i]);
622     }
623     WriteEnd(context);
624     if (RpcClientCall(client, "RegisterStaEventCallback") != WIFI_HAL_OPT_OK) {
625         if (callback.onConnectChanged == NULL) {
626             SetWifiEventCallback(callback);
627         }
628         return WIFI_HAL_OPT_FAILED;
629     }
630     int result = WIFI_HAL_OPT_FAILED;
631     ReadInt(context, &result);
632     if (result == WIFI_HAL_OPT_OK || callback.onConnectChanged == NULL) {
633         SetWifiEventCallback(callback);
634     }
635     ReadClientEnd(client);
636     UnlockRpcClient(client);
637     return result;
638 }
639 
StartWpsPbcMode(WifiWpsParam * param)640 WifiErrorNo StartWpsPbcMode(WifiWpsParam *param)
641 {
642     if (param == NULL) {
643         return WIFI_HAL_OPT_FAILED;
644     }
645     RpcClient *client = GetStaRpcClient();
646     LockRpcClient(client);
647     Context *context = client->context;
648     WriteBegin(context, 0);
649     WriteFunc(context, "StartWpsPbcMode");
650     WriteInt(context, param->anyFlag);
651     WriteInt(context, param->multiAp);
652     WriteStr(context, param->bssid);
653     WriteEnd(context);
654     if (RpcClientCall(client, "StartWpsPbcMode") != WIFI_HAL_OPT_OK) {
655         return WIFI_HAL_OPT_FAILED;
656     }
657     int result = WIFI_HAL_OPT_FAILED;
658     ReadInt(context, &result);
659     ReadClientEnd(client);
660     UnlockRpcClient(client);
661     return result;
662 }
663 
StartWpsPinMode(WifiWpsParam * param,int * pinCode)664 WifiErrorNo StartWpsPinMode(WifiWpsParam *param, int *pinCode)
665 {
666     if (param == NULL || pinCode == NULL) {
667         return WIFI_HAL_OPT_FAILED;
668     }
669     RpcClient *client = GetStaRpcClient();
670     LockRpcClient(client);
671     Context *context = client->context;
672     WriteBegin(context, 0);
673     WriteFunc(context, "StartWpsPinMode");
674     WriteInt(context, param->anyFlag);
675     WriteInt(context, param->multiAp);
676     WriteStr(context, param->bssid);
677     WriteStr(context, param->pinCode);
678     WriteEnd(context);
679     if (RpcClientCall(client, "StartWpsPinMode") != WIFI_HAL_OPT_OK) {
680         return WIFI_HAL_OPT_FAILED;
681     }
682     int result = WIFI_HAL_OPT_FAILED;
683     ReadInt(context, &result);
684     if (result == WIFI_HAL_OPT_OK) {
685         ReadInt(context, pinCode);
686     }
687     ReadClientEnd(client);
688     UnlockRpcClient(client);
689     return result;
690 }
691 
StopWps(void)692 WifiErrorNo StopWps(void)
693 {
694     RpcClient *client = GetStaRpcClient();
695     LockRpcClient(client);
696     Context *context = client->context;
697     WriteBegin(context, 0);
698     WriteFunc(context, "StopWps");
699     WriteEnd(context);
700     if (RpcClientCall(client, "StopWps") != WIFI_HAL_OPT_OK) {
701         return WIFI_HAL_OPT_FAILED;
702     }
703     int result = WIFI_HAL_OPT_FAILED;
704     ReadInt(context, &result);
705     ReadClientEnd(client);
706     UnlockRpcClient(client);
707     return result;
708 }
709 
GetRoamingCapabilities(WifiRoamCapability * capability)710 WifiErrorNo GetRoamingCapabilities(WifiRoamCapability *capability)
711 {
712     if (capability == NULL) {
713         return WIFI_HAL_OPT_FAILED;
714     }
715     RpcClient *client = GetStaRpcClient();
716     LockRpcClient(client);
717     Context *context = client->context;
718     WriteBegin(context, 0);
719     WriteFunc(context, "GetRoamingCapabilities");
720     WriteEnd(context);
721     if (RpcClientCall(client, "GetRoamingCapabilities") != WIFI_HAL_OPT_OK) {
722         return WIFI_HAL_OPT_FAILED;
723     }
724     int result = WIFI_HAL_OPT_FAILED;
725     ReadInt(context, &result);
726     if (result == WIFI_HAL_OPT_OK) {
727         ReadInt(context, &capability->maxBlocklistSize);
728         ReadInt(context, &capability->maxTrustlistSize);
729     }
730     ReadClientEnd(client);
731     UnlockRpcClient(client);
732     return result;
733 }
734 
SetRoamConfig(char ** blocklist,int blocksize,char ** trustlist,int trustsize)735 WifiErrorNo SetRoamConfig(char **blocklist, int blocksize, char **trustlist, int trustsize)
736 {
737     RpcClient *client = GetStaRpcClient();
738     LockRpcClient(client);
739     Context *context = client->context;
740     WriteBegin(context, 0);
741     WriteFunc(context, "SetRoamConfig");
742     WriteInt(context, blocksize);
743     if (blocksize > 0 && blocklist != NULL) {
744         for (int i = 0; i < blocksize; ++i) {
745             WriteStr(context, blocklist[i]);
746         }
747     }
748     WriteInt(context, trustsize);
749     if (trustsize > 0 && trustlist != NULL) {
750         for (int i = 0; i < trustsize; ++i) {
751             WriteStr(context, trustlist[i]);
752         }
753     }
754     WriteEnd(context);
755     if (RpcClientCall(client, "SetRoamConfig") != WIFI_HAL_OPT_OK) {
756         return WIFI_HAL_OPT_FAILED;
757     }
758     int result = WIFI_HAL_OPT_FAILED;
759     ReadInt(context, &result);
760     ReadClientEnd(client);
761     UnlockRpcClient(client);
762     return result;
763 }
764 
WpaAutoConnect(int enable)765 WifiErrorNo WpaAutoConnect(int enable)
766 {
767     RpcClient *client = GetStaRpcClient();
768     LockRpcClient(client);
769     Context *context = client->context;
770     WriteBegin(context, 0);
771     WriteFunc(context, "WpaAutoConnect");
772     WriteInt(context, enable);
773     WriteEnd(context);
774     if (RpcClientCall(client, "WpaAutoConnect") != WIFI_HAL_OPT_OK) {
775         return WIFI_HAL_OPT_FAILED;
776     }
777     int result = WIFI_HAL_OPT_FAILED;
778     ReadInt(context, &result);
779     if (result != WIFI_HAL_OPT_OK) {
780         LOGE("WpaAutoConnect failed!");
781     }
782     ReadClientEnd(client);
783     UnlockRpcClient(client);
784     return result;
785 }
786 
787 
WpaBlocklistClear(void)788 WifiErrorNo WpaBlocklistClear(void)
789 {
790     RpcClient *client = GetStaRpcClient();
791     LockRpcClient(client);
792     Context *context = client->context;
793     WriteBegin(context, 0);
794     WriteFunc(context, "WpaBlocklistClear");
795     WriteEnd(context);
796     if (RpcClientCall(client, "WpaBlocklistClear") != WIFI_HAL_OPT_OK) {
797         return WIFI_HAL_OPT_FAILED;
798     }
799     int result = WIFI_HAL_OPT_FAILED;
800     ReadInt(context, &result);
801     if (result != WIFI_HAL_OPT_OK) {
802         LOGE("WpaBlocklistClear failed!");
803     }
804     ReadClientEnd(client);
805     UnlockRpcClient(client);
806     return result;
807 }
808 
GetConnectSignalInfo(const char * endBssid,WpaSignalInfo * info)809 WifiErrorNo GetConnectSignalInfo(const char *endBssid, WpaSignalInfo *info)
810 {
811     RpcClient *client = GetStaRpcClient();
812     LockRpcClient(client);
813     Context *context = client->context;
814     WriteBegin(context, 0);
815     WriteFunc(context, "GetConnectSignalInfo");
816     WriteStr(context, endBssid);
817     WriteEnd(context);
818     if (RpcClientCall(client, "GetConnectSignalInfo") != WIFI_HAL_OPT_OK) {
819         return WIFI_HAL_OPT_FAILED;
820     }
821     int result = WIFI_HAL_OPT_FAILED;
822     ReadInt(context, &result);
823     if (result != WIFI_HAL_OPT_OK) {
824         LOGE("GetConnectSignalInfo failed!");
825     } else {
826         ReadInt(context, &info->signal);
827         ReadInt(context, &info->txrate);
828         ReadInt(context, &info->rxrate);
829         ReadInt(context, &info->noise);
830         ReadInt(context, &info->frequency);
831         ReadInt(context, &info->txPackets);
832         ReadInt(context, &info->rxPackets);
833         ReadInt(context, &info->snr);
834         ReadInt(context, &info->chload);
835         ReadInt(context, &info->ulDelay);
836         ReadInt(context, &info->txBytes);
837         ReadInt(context, &info->rxBytes);
838         ReadInt(context, &info->txFailed);
839     }
840     ReadClientEnd(client);
841     UnlockRpcClient(client);
842     return result;
843 }
844 
SetSuspendMode(bool mode)845 WifiErrorNo SetSuspendMode(bool mode)
846 {
847     RpcClient *client = GetStaRpcClient();
848     LockRpcClient(client);
849     Context *context = client->context;
850     WriteBegin(context, 0);
851     WriteFunc(context, "SetSuspendMode");
852     WriteInt(context, mode);
853     WriteEnd(context);
854     if (RpcClientCall(client, "SetSuspendMode") != WIFI_HAL_OPT_OK) {
855         return WIFI_HAL_OPT_FAILED;
856     }
857     int result = WIFI_HAL_OPT_FAILED;
858     ReadInt(context, &result);
859     ReadClientEnd(client);
860     UnlockRpcClient(client);
861     return result;
862 }
863 
SetPowerMode(bool mode)864 WifiErrorNo SetPowerMode(bool mode)
865 {
866     RpcClient *client = GetStaRpcClient();
867     LockRpcClient(client);
868     Context *context = client->context;
869     WriteBegin(context, 0);
870     WriteFunc(context, "SetPowerMode");
871     WriteInt(context, mode);
872     WriteEnd(context);
873     if (RpcClientCall(client, "SetPowerMode") != WIFI_HAL_OPT_OK) {
874         return WIFI_HAL_OPT_FAILED;
875     }
876     int result = WIFI_HAL_OPT_FAILED;
877     ReadInt(context, &result);
878     ReadClientEnd(client);
879     UnlockRpcClient(client);
880     return result;
881 }
882 
883