1 /*
2  * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "wifi_hal_crpc_sta.h"
17 #include "serial.h"
18 #include "wifi_hal_crpc_base.h"
19 #include "wifi_hal_sta_interface.h"
20 #include "wifi_hal_define.h"
21 
22 #define NETWORK_MAX_SIZE 32
23 #define WIFI_IDL_GET_MAX_SCAN_INFO 256
24 #define WIFI_IDL_GET_MAX_BANDS 32
25 #define WIFI_IDL_GET_MAX_NETWORK_LIST 128
26 
RpcStart(RpcServer * server,Context * context)27 int RpcStart(RpcServer *server, Context *context)
28 {
29     if (server == NULL || context == NULL) {
30         return HAL_FAILURE;
31     }
32     WifiErrorNo err = Start();
33     WriteBegin(context, 0);
34     WriteInt(context, err);
35     WriteEnd(context);
36     return HAL_SUCCESS;
37 }
38 
RpcStop(RpcServer * server,Context * context)39 int RpcStop(RpcServer *server, Context *context)
40 {
41     if (server == NULL || context == NULL) {
42         return HAL_FAILURE;
43     }
44     WifiErrorNo err = Stop();
45     WriteBegin(context, 0);
46     WriteInt(context, err);
47     WriteEnd(context);
48     return HAL_SUCCESS;
49 }
50 
RpcStartScan(RpcServer * server,Context * context)51 int RpcStartScan(RpcServer *server, Context *context)
52 {
53     if (server == NULL || context == NULL) {
54         return HAL_FAILURE;
55     }
56     ScanSettings setting = {0};
57     int ret = -1;
58     do {
59         if (ReadInt(context, &setting.hiddenSsidSize) < 0) {
60             break;
61         }
62         if (setting.hiddenSsidSize > 0) {
63             setting.hiddenSsid = ReadCharArray(context, setting.hiddenSsidSize);
64             if (setting.hiddenSsid == NULL) {
65                 break;
66             }
67         }
68         if (ReadInt(context, &setting.freqSize) < 0) {
69             break;
70         }
71         if (setting.freqSize > 0) {
72             setting.freqs = ReadIntArray(context, setting.freqSize);
73             if (setting.freqs == NULL) {
74                 break;
75             }
76         }
77         int temp = 0;
78         if (ReadInt(context, &temp) < 0) {
79             break;
80         }
81         setting.scanStyle = (ScanStyle)temp;
82 
83         ret += 1; /* deal success, set ret = 0 */
84         WifiErrorNo err = StartScan(&setting);
85         WriteBegin(context, 0);
86         WriteInt(context, err);
87         WriteEnd(context);
88     } while (0);
89     if (setting.hiddenSsid != NULL) {
90         for (int i = 0; i < setting.hiddenSsidSize; ++i) {
91             free(setting.hiddenSsid[i]);
92             setting.hiddenSsid[i] = NULL;
93         }
94         free(setting.hiddenSsid);
95         setting.hiddenSsid = NULL;
96     }
97     if (setting.freqs != NULL) {
98         free(setting.freqs);
99         setting.freqs = NULL;
100     }
101     return ret;
102 }
103 
RpcGetScanInfos(RpcServer * server,Context * context)104 int RpcGetScanInfos(RpcServer *server, Context *context)
105 {
106     if (server == NULL || context == NULL) {
107         return HAL_FAILURE;
108     }
109     int maxSize = 0;
110     if (ReadInt(context, &maxSize) < 0) {
111         return HAL_FAILURE;
112     }
113     ScanInfo *results = NULL;
114     if (maxSize > 0 && maxSize <= WIFI_IDL_GET_MAX_SCAN_INFO) {
115         results = (ScanInfo *)calloc(maxSize, sizeof(ScanInfo));
116     }
117     if (results == NULL) {
118         return HAL_FAILURE;
119     }
120     WifiErrorNo err = GetScanInfos(results, &maxSize);
121     WriteBegin(context, 0);
122     WriteInt(context, err);
123     struct timespec clockTime = {0, 0};
124     const int secComplex = 1000;
125     clock_gettime(CLOCK_MONOTONIC, &clockTime);
126     if (err == WIFI_HAL_SUCCESS) {
127         WriteInt(context, maxSize);
128         for (int i = 0; i < maxSize; ++i) {
129             WriteStr(context, results[i].bssid);
130             WriteInt(context, results[i].freq);
131             WriteInt(context, results[i].siglv);
132             WriteStr(context, results[i].flags);
133             WriteStr(context, results[i].ssid);
134             int64_t currTime = (int64_t)clockTime.tv_sec * secComplex * secComplex + clockTime.tv_nsec / secComplex;
135             WriteInt64(context, currTime);
136             WriteInt(context, results[i].channelWidth);
137             WriteInt(context, results[i].centerFrequency0);
138             WriteInt(context, results[i].centerFrequency1);
139             WriteInt(context, results[i].isVhtInfoExist);
140             WriteInt(context, results[i].isHtInfoExist);
141             WriteInt(context, results[i].isHeInfoExist);
142             WriteInt(context, results[i].isErpExist);
143             WriteInt(context, results[i].maxRates);
144             WriteInt(context, results[i].extMaxRates);
145             WriteInt(context, results[i].ieSize);
146             for (int j = 0; j < results[i].ieSize; ++j) {
147                 WriteInt(context, results[i].infoElems[j].id);
148                 WriteInt(context, results[i].infoElems[j].size);
149                 WriteUStr(context, (unsigned char *)results[i].infoElems[j].content, results[i].infoElems[j].size);
150                 free(results[i].infoElems[j].content);
151                 results[i].infoElems[j].content = NULL;
152             }
153             if (results[i].infoElems != NULL) {
154                 free(results[i].infoElems);
155                 results[i].infoElems = NULL;
156             }
157         }
158     }
159     WriteEnd(context);
160     free(results);
161     results = NULL;
162     return HAL_SUCCESS;
163 }
164 
ReadPnoScanSettings(Context * context,PnoScanSettings * pSetting)165 static int ReadPnoScanSettings(Context *context, PnoScanSettings *pSetting)
166 {
167     if (ReadInt(context, &pSetting->scanInterval) < 0 || ReadInt(context, &pSetting->minRssi2Dot4Ghz) < 0 ||
168         ReadInt(context, &pSetting->minRssi5Ghz) < 0 || ReadInt(context, &pSetting->hiddenSsidSize) < 0) {
169         return HAL_FAILURE;
170     }
171     if (pSetting->hiddenSsidSize > 0) {
172         pSetting->hiddenSsid = ReadCharArray(context, pSetting->hiddenSsidSize);
173         if (pSetting->hiddenSsid == NULL) {
174             return HAL_FAILURE;
175         }
176     }
177     if (ReadInt(context, &pSetting->savedSsidSize) < 0) {
178         return HAL_FAILURE;
179     }
180     if (pSetting->savedSsidSize > 0) {
181         pSetting->savedSsid = ReadCharArray(context, pSetting->savedSsidSize);
182         if (pSetting->savedSsid == NULL) {
183             return HAL_FAILURE;
184         }
185     }
186     if (ReadInt(context, &pSetting->freqSize) < 0) {
187         return HAL_FAILURE;
188     }
189     if (pSetting->freqSize > 0) {
190         pSetting->freqs = ReadIntArray(context, pSetting->freqSize);
191         if (pSetting->freqs == NULL) {
192             return HAL_FAILURE;
193         }
194     }
195     return HAL_SUCCESS;
196 }
197 
RpcStartPnoScan(RpcServer * server,Context * context)198 int RpcStartPnoScan(RpcServer *server, Context *context)
199 {
200     if (server == NULL || context == NULL) {
201         return HAL_FAILURE;
202     }
203     PnoScanSettings setting = {0};
204     int ret = ReadPnoScanSettings(context, &setting);
205     if (ret == 0) {
206         WifiErrorNo err = StartPnoScan(&setting);
207         WriteBegin(context, 0);
208         WriteInt(context, err);
209         WriteEnd(context);
210     }
211     if (setting.hiddenSsid != NULL) {
212         for (int i = 0; i < setting.hiddenSsidSize; ++i) {
213             free(setting.hiddenSsid[i]);
214             setting.hiddenSsid[i] = NULL;
215         }
216         free(setting.hiddenSsid);
217         setting.hiddenSsid = NULL;
218     }
219     if (setting.savedSsid != NULL) {
220         for (int i = 0; i < setting.savedSsidSize; ++i) {
221             free(setting.savedSsid[i]);
222             setting.savedSsid[i] = NULL;
223         }
224         free(setting.savedSsid);
225         setting.savedSsid = NULL;
226     }
227     if (setting.freqs != NULL) {
228         free(setting.freqs);
229         setting.freqs = NULL;
230     }
231 
232     return ret;
233 }
234 
RpcStopPnoScan(RpcServer * server,Context * context)235 int RpcStopPnoScan(RpcServer *server, Context *context)
236 {
237     if (server == NULL || context == NULL) {
238         return HAL_FAILURE;
239     }
240     WifiErrorNo err = StopPnoScan();
241     WriteBegin(context, 0);
242     WriteInt(context, err);
243     WriteEnd(context);
244     return HAL_SUCCESS;
245 }
246 
RpcConnect(RpcServer * server,Context * context)247 int RpcConnect(RpcServer *server, Context *context)
248 {
249     if (server == NULL || context == NULL) {
250         return HAL_FAILURE;
251     }
252     int networkId = 0;
253     if (ReadInt(context, &networkId) < 0) {
254         return HAL_FAILURE;
255     }
256     WifiErrorNo err = Connect(networkId);
257     WriteBegin(context, 0);
258     WriteInt(context, err);
259     WriteEnd(context);
260     return HAL_SUCCESS;
261 }
262 
RpcReconnect(RpcServer * server,Context * context)263 int RpcReconnect(RpcServer *server, Context *context)
264 {
265     if (server == NULL || context == NULL) {
266         return HAL_FAILURE;
267     }
268     WifiErrorNo err = Reconnect();
269     WriteBegin(context, 0);
270     WriteInt(context, err);
271     WriteEnd(context);
272     return HAL_SUCCESS;
273 }
274 
RpcReassociate(RpcServer * server,Context * context)275 int RpcReassociate(RpcServer *server, Context *context)
276 {
277     if (server == NULL || context == NULL) {
278         return HAL_FAILURE;
279     }
280     WifiErrorNo err = Reassociate();
281     WriteBegin(context, 0);
282     WriteInt(context, err);
283     WriteEnd(context);
284     return HAL_SUCCESS;
285 }
286 
RpcDisconnect(RpcServer * server,Context * context)287 int RpcDisconnect(RpcServer *server, Context *context)
288 {
289     if (server == NULL || context == NULL) {
290         return HAL_FAILURE;
291     }
292     WifiErrorNo err = Disconnect();
293     WriteBegin(context, 0);
294     WriteInt(context, err);
295     WriteEnd(context);
296     return HAL_SUCCESS;
297 }
298 
RpcGetStaCapabilities(RpcServer * server,Context * context)299 int RpcGetStaCapabilities(RpcServer *server, Context *context)
300 {
301     if (server == NULL || context == NULL) {
302         return HAL_FAILURE;
303     }
304     int32_t capabilities = 0;
305     WifiErrorNo err = GetStaCapabilities(&capabilities);
306     WriteBegin(context, 0);
307     WriteInt(context, err);
308     if (err == WIFI_HAL_SUCCESS) {
309         WriteInt(context, capabilities);
310     }
311     WriteEnd(context);
312     return HAL_SUCCESS;
313 }
314 
RpcGetDeviceMacAddress(RpcServer * server,Context * context)315 int RpcGetDeviceMacAddress(RpcServer *server, Context *context)
316 {
317     if (server == NULL || context == NULL) {
318         return HAL_FAILURE;
319     }
320     int maxSize = 0;
321     if (ReadInt(context, &maxSize) < 0 || maxSize <= 0) {
322         return HAL_FAILURE;
323     }
324     unsigned char *mac = NULL;
325     if (maxSize > 0) {
326         mac = (unsigned char *)calloc(maxSize + 1, sizeof(unsigned char));
327     }
328     if (mac == NULL) {
329         return HAL_FAILURE;
330     }
331     WifiErrorNo err = GetDeviceMacAddress(mac, &maxSize);
332     WriteBegin(context, 0);
333     WriteInt(context, err);
334     if (err == WIFI_HAL_SUCCESS) {
335         WriteInt(context, maxSize);
336         WriteUStr(context, mac, maxSize);
337     }
338     WriteEnd(context);
339     free(mac);
340     mac = NULL;
341     return HAL_SUCCESS;
342 }
343 
RpcGetFrequencies(RpcServer * server,Context * context)344 int RpcGetFrequencies(RpcServer *server, Context *context)
345 {
346     if (server == NULL || context == NULL) {
347         return HAL_FAILURE;
348     }
349     int band = 0;
350     int maxSize = 0;
351     if (ReadInt(context, &band) < 0 || ReadInt(context, &maxSize) < 0 || maxSize <= 0
352         || maxSize > WIFI_IDL_GET_MAX_BANDS) {
353         return HAL_FAILURE;
354     }
355     int *frequencies = (int *)calloc(maxSize, sizeof(int));
356     if (frequencies == NULL) {
357         return HAL_FAILURE;
358     }
359     WifiErrorNo err = GetFrequencies(band, frequencies, &maxSize);
360     WriteBegin(context, 0);
361     WriteInt(context, err);
362     if (err == WIFI_HAL_SUCCESS) {
363         WriteInt(context, maxSize);
364         for (int i = 0; i < maxSize; ++i) {
365             WriteInt(context, frequencies[i]);
366         }
367     }
368     WriteEnd(context);
369     free(frequencies);
370     frequencies = NULL;
371     return HAL_SUCCESS;
372 }
373 
RpcSetAssocMacAddr(RpcServer * server,Context * context)374 int RpcSetAssocMacAddr(RpcServer *server, Context *context)
375 {
376     if (server == NULL || context == NULL) {
377         return HAL_FAILURE;
378     }
379     int maxSize = 0;
380     if (ReadInt(context, &maxSize) < 0) {
381         return HAL_FAILURE;
382     }
383     int len = maxSize + 1;
384     unsigned char *mac = (unsigned char *)calloc(len, sizeof(unsigned char));
385     if (mac == NULL) {
386         return HAL_FAILURE;
387     }
388     if (ReadUStr(context, mac, len) != 0) {
389         free(mac);
390         mac = NULL;
391         return HAL_FAILURE;
392     }
393     int portType = -1;
394     if (ReadInt(context, &portType) < 0) {
395         return HAL_FAILURE;
396     }
397     WifiErrorNo err = SetAssocMacAddr(mac, maxSize, portType);
398     WriteBegin(context, 0);
399     WriteInt(context, err);
400     WriteEnd(context);
401     free(mac);
402     mac = NULL;
403     return HAL_SUCCESS;
404 }
405 
RpcSetScanningMacAddress(RpcServer * server,Context * context)406 int RpcSetScanningMacAddress(RpcServer *server, Context *context)
407 {
408     if (server == NULL || context == NULL) {
409         return HAL_FAILURE;
410     }
411     int maxSize = 0;
412     if (ReadInt(context, &maxSize) < 0 || maxSize < 0) {
413         return HAL_FAILURE;
414     }
415     int len = maxSize + 1;
416     unsigned char *mac = (unsigned char *)calloc(len, sizeof(unsigned char));
417     if (mac == NULL) {
418         return HAL_FAILURE;
419     }
420     if (ReadUStr(context, mac, len) != 0) {
421         free(mac);
422         mac = NULL;
423         return HAL_FAILURE;
424     }
425     WifiErrorNo err = SetScanningMacAddress(mac, maxSize);
426     WriteBegin(context, 0);
427     WriteInt(context, err);
428     WriteEnd(context);
429     free(mac);
430     mac = NULL;
431     return HAL_SUCCESS;
432 }
433 
RpcDeauthLastRoamingBssid(RpcServer * server,Context * context)434 int RpcDeauthLastRoamingBssid(RpcServer *server, Context *context)
435 {
436     if (server == NULL || context == NULL) {
437         return HAL_FAILURE;
438     }
439     int maxSize = 0;
440     if (ReadInt(context, &maxSize) < 0 || maxSize < 0) {
441         return HAL_FAILURE;
442     }
443     int len = maxSize + 1;
444     unsigned char *mac = (unsigned char *)calloc(len, sizeof(unsigned char));
445     if (mac == NULL) {
446         return HAL_FAILURE;
447     }
448     if (ReadUStr(context, mac, len) != 0) {
449         free(mac);
450         mac = NULL;
451         return HAL_FAILURE;
452     }
453     WifiErrorNo err = DeauthLastRoamingBssid(mac, maxSize);
454     WriteBegin(context, 0);
455     WriteInt(context, err);
456     WriteEnd(context);
457     free(mac);
458     mac = NULL;
459     return HAL_SUCCESS;
460 }
461 
RpcGetSupportFeature(RpcServer * server,Context * context)462 int RpcGetSupportFeature(RpcServer *server, Context *context)
463 {
464     if (server == NULL || context == NULL) {
465         return HAL_FAILURE;
466     }
467     long feature = 0;
468     WifiErrorNo err = GetSupportFeature(&feature);
469     WriteBegin(context, 0);
470     WriteInt(context, err);
471     if (err == WIFI_HAL_SUCCESS) {
472         WriteLong(context, feature);
473     }
474     WriteEnd(context);
475     return HAL_SUCCESS;
476 }
477 
RpcRunCmd(RpcServer * server,Context * context)478 int RpcRunCmd(RpcServer *server, Context *context)
479 {
480     if (server == NULL || context == NULL) {
481         return HAL_FAILURE;
482     }
483     char ifname[WIFI_IFACE_NAME_MAXLEN] = {0};
484     char *pIfName = NULL;
485     int ret = ReadStr(context, ifname, WIFI_IFACE_NAME_MAXLEN);
486     if (ret < 0) {
487         return HAL_FAILURE;
488     } else if (ret > 0) {
489         int len = ret + 1;
490         pIfName = (char *)calloc(len, sizeof(char));
491         if (pIfName == NULL) {
492             return HAL_FAILURE;
493         }
494         if (ReadStr(context, pIfName, len) != 0) {
495             free(pIfName);
496             pIfName = NULL;
497             return HAL_FAILURE;
498         }
499     }
500     int cmdid = 0;
501     int bufsize = 0;
502     if (ReadInt(context, &cmdid) < 0 || ReadInt(context, &bufsize) < 0 || bufsize < 0) {
503         free(pIfName);
504         pIfName = NULL;
505         return HAL_FAILURE;
506     }
507     int len = bufsize + 1;
508     unsigned char *buf = (unsigned char *)calloc(len, sizeof(unsigned char));
509     if (buf == NULL) {
510         free(pIfName);
511         pIfName = NULL;
512         return HAL_FAILURE;
513     }
514     if (ReadUStr(context, buf, len) != 0) {
515         free(pIfName);
516         free(buf);
517         pIfName = NULL;
518         buf = NULL;
519         return HAL_FAILURE;
520     }
521     WifiErrorNo err = RunCmd((pIfName == NULL) ? ifname : pIfName, cmdid, buf, bufsize);
522     WriteBegin(context, 0);
523     WriteInt(context, err);
524     WriteEnd(context);
525     free(pIfName);
526     free(buf);
527     pIfName = NULL;
528     buf = NULL;
529     return HAL_SUCCESS;
530 }
531 
RpcSetWifiTxPower(RpcServer * server,Context * context)532 int RpcSetWifiTxPower(RpcServer *server, Context *context)
533 {
534     if (server == NULL || context == NULL) {
535         return HAL_FAILURE;
536     }
537     int32_t power = 0;
538     if (ReadInt(context, &power) < 0) {
539         return HAL_FAILURE;
540     }
541     WifiErrorNo err = SetWifiTxPower(power);
542     WriteBegin(context, 0);
543     WriteInt(context, err);
544     WriteEnd(context);
545     return HAL_SUCCESS;
546 }
547 
RpcRemoveNetwork(RpcServer * server,Context * context)548 int RpcRemoveNetwork(RpcServer *server, Context *context)
549 {
550     if (server == NULL || context == NULL) {
551         return HAL_FAILURE;
552     }
553     int32_t networkId = 0;
554     if (ReadInt(context, &networkId) < 0) {
555         return HAL_FAILURE;
556     }
557     WifiErrorNo err = RemoveNetwork(networkId);
558     WriteBegin(context, 0);
559     WriteInt(context, err);
560     WriteEnd(context);
561     return HAL_SUCCESS;
562 }
563 
RpcAddNetwork(RpcServer * server,Context * context)564 int RpcAddNetwork(RpcServer *server, Context *context)
565 {
566     if (server == NULL || context == NULL) {
567         return HAL_FAILURE;
568     }
569     int networkId = 0;
570     WifiErrorNo err = AddNetwork(&networkId);
571     WriteBegin(context, 0);
572     WriteInt(context, err);
573     if (err == WIFI_HAL_SUCCESS) {
574         WriteInt(context, networkId);
575     }
576     WriteEnd(context);
577     return HAL_SUCCESS;
578 }
579 
RpcEnableNetwork(RpcServer * server,Context * context)580 int RpcEnableNetwork(RpcServer *server, Context *context)
581 {
582     if (server == NULL || context == NULL) {
583         return HAL_FAILURE;
584     }
585     int networkId = 0;
586     if (ReadInt(context, &networkId) < 0) {
587         return HAL_FAILURE;
588     }
589     WifiErrorNo err = EnableNetwork(networkId);
590     WriteBegin(context, 0);
591     WriteInt(context, err);
592     WriteEnd(context);
593     return HAL_SUCCESS;
594 }
595 
RpcDisableNetwork(RpcServer * server,Context * context)596 int RpcDisableNetwork(RpcServer *server, Context *context)
597 {
598     if (server == NULL || context == NULL) {
599         return HAL_FAILURE;
600     }
601     int networkId = 0;
602     if (ReadInt(context, &networkId) < 0) {
603         return HAL_FAILURE;
604     }
605     WifiErrorNo err = DisableNetwork(networkId);
606     WriteBegin(context, 0);
607     WriteInt(context, err);
608     WriteEnd(context);
609     return HAL_SUCCESS;
610 }
611 
RpcSetNetwork(RpcServer * server,Context * context)612 int RpcSetNetwork(RpcServer *server, Context *context)
613 {
614     if (server == NULL || context == NULL) {
615         return HAL_FAILURE;
616     }
617     int networkId = 0;
618     if (ReadInt(context, &networkId) < 0) {
619         return HAL_FAILURE;
620     }
621     int size = 0;
622     if (ReadInt(context, &size) < 0) {
623         return HAL_FAILURE;
624     }
625     if (size <= 0 || size > NETWORK_MAX_SIZE) {
626         return HAL_FAILURE;
627     }
628 
629     SetNetworkConfig *confs = (SetNetworkConfig *)calloc(size, sizeof(SetNetworkConfig));
630     if (confs == NULL) {
631         return HAL_FAILURE;
632     }
633 
634     int flag = 0;
635     for (int i = 0; i < size; ++i) {
636         if (ReadInt(context, (int *)&(confs[i].cfgParam)) < 0 ||
637             ReadStr(context, confs[i].cfgValue, sizeof(confs[i].cfgValue)) != 0) {
638             flag = 1;
639             break;
640         }
641     }
642     WifiErrorNo err = WIFI_HAL_FAILED;
643     if (flag == 0) {
644         err = SetNetwork(networkId, confs, size);
645     }
646     WriteBegin(context, 0);
647     WriteInt(context, err);
648     WriteEnd(context);
649     free(confs);
650     confs = NULL;
651     return HAL_SUCCESS;
652 }
653 
RpcSaveNetworkConfig(RpcServer * server,Context * context)654 int RpcSaveNetworkConfig(RpcServer *server, Context *context)
655 {
656     if (server == NULL || context == NULL) {
657         return HAL_FAILURE;
658     }
659     WifiErrorNo err = SaveNetworkConfig();
660     WriteBegin(context, 0);
661     WriteInt(context, err);
662     WriteEnd(context);
663     return HAL_SUCCESS;
664 }
665 
RpcStartWpsPbcMode(RpcServer * server,Context * context)666 int RpcStartWpsPbcMode(RpcServer *server, Context *context)
667 {
668     if (server == NULL || context == NULL) {
669         return HAL_FAILURE;
670     }
671     WifiWpsParam param = {0};
672     if (ReadInt(context, &param.anyFlag) < 0) {
673         return HAL_FAILURE;
674     }
675     if (ReadInt(context, &param.multiAp) < 0) {
676         return HAL_FAILURE;
677     }
678     if (ReadStr(context, param.bssid, sizeof(param.bssid)) != 0) {
679         return HAL_FAILURE;
680     }
681     WifiErrorNo err = StartWpsPbcMode(&param);
682     WriteBegin(context, 0);
683     WriteInt(context, err);
684     WriteEnd(context);
685     return HAL_SUCCESS;
686 }
687 
RpcStartWpsPinMode(RpcServer * server,Context * context)688 int RpcStartWpsPinMode(RpcServer *server, Context *context)
689 {
690     if (server == NULL || context == NULL) {
691         return HAL_FAILURE;
692     }
693     WifiWpsParam param = {0};
694     if (ReadInt(context, &param.anyFlag) < 0) {
695         return HAL_FAILURE;
696     }
697     if (ReadInt(context, &param.multiAp) < 0) {
698         return HAL_FAILURE;
699     }
700     if (ReadStr(context, param.bssid, sizeof(param.bssid)) != 0) {
701         return HAL_FAILURE;
702     }
703     int pinCode = 0;
704     WifiErrorNo err = StartWpsPinMode(&param, &pinCode);
705     WriteBegin(context, 0);
706     WriteInt(context, err);
707     if (err == WIFI_HAL_SUCCESS) {
708         WriteInt(context, pinCode);
709     }
710     WriteEnd(context);
711     return HAL_SUCCESS;
712 }
713 
RpcStopWps(RpcServer * server,Context * context)714 int RpcStopWps(RpcServer *server, Context *context)
715 {
716     if (server == NULL || context == NULL) {
717         return HAL_FAILURE;
718     }
719     WifiErrorNo err = StopWps();
720     WriteBegin(context, 0);
721     WriteInt(context, err);
722     WriteEnd(context);
723     return HAL_SUCCESS;
724 }
725 
RpcGetRoamingCapabilities(RpcServer * server,Context * context)726 int RpcGetRoamingCapabilities(RpcServer *server, Context *context)
727 {
728     if (server == NULL || context == NULL) {
729         return HAL_FAILURE;
730     }
731     WifiRoamCapability capability = {0};
732     WifiErrorNo err = GetRoamingCapabilities(&capability);
733     WriteBegin(context, 0);
734     WriteInt(context, err);
735     if (err == WIFI_HAL_SUCCESS) {
736         WriteInt(context, capability.maxBlocklistSize);
737         WriteInt(context, capability.maxTrustlistSize);
738     }
739     WriteEnd(context);
740     return HAL_SUCCESS;
741 }
742 
ReadRoamBlockList(Context * context,int size)743 static char **ReadRoamBlockList(Context *context, int size)
744 {
745     if (size <= 0) {
746         return NULL;
747     }
748 
749     char **list = (char **)calloc(size, sizeof(char *));
750     if (list == NULL) {
751         return NULL;
752     }
753     int i = 0;
754     for (; i < size; ++i) {
755         int len = ReadStr(context, NULL, 0);
756         if (len < 0) {
757             break;
758         }
759         ++len;
760         list[i] = (char *)calloc(len, sizeof(char));
761         if (list[i] == NULL) {
762             break;
763         }
764         if (ReadStr(context, list[i], len) != 0) {
765             free(list[i]);
766             list[i] = NULL;
767             return NULL;
768         }
769     }
770     if (i < size) {
771         for (int j = 0; j <= i; ++j) {
772             free(list[j]);
773             list[j] = NULL;
774         }
775         free(list);
776         list = NULL;
777         return NULL;
778     } else {
779         return list;
780     }
781 }
782 
RpcSetRoamConfig(RpcServer * server,Context * context)783 int RpcSetRoamConfig(RpcServer *server, Context *context)
784 {
785     if (server == NULL || context == NULL) {
786         return HAL_FAILURE;
787     }
788     int blocksize = 0;
789     char **blocklist = NULL;
790     int size = 0;
791     char **trustlist = NULL;
792     int ret = -1;
793 
794     do {
795         if (ReadInt(context, &blocksize) < 0) {
796             break;
797         }
798         if (blocksize > 0) {
799             blocklist = ReadRoamBlockList(context, blocksize);
800             if (blocklist == NULL) {
801                 break;
802             }
803         }
804 
805         if (ReadInt(context, &size) < 0) {
806             break;
807         }
808         if (size > 0) {
809             trustlist = ReadRoamBlockList(context, size);
810             if (trustlist == NULL) {
811                 break;
812             }
813         }
814         ret += 1; /* deal success, set ret = 0 */
815         WifiErrorNo err = SetRoamConfig(blocklist, blocksize, trustlist, size);
816         WriteBegin(context, 0);
817         WriteInt(context, err);
818         WriteEnd(context);
819     } while (0);
820     if (blocklist != NULL) {
821         for (int i = 0; i < blocksize; ++i) {
822             free(blocklist[i]);
823             blocklist[i] = NULL;
824         }
825         free(blocklist);
826         blocklist = NULL;
827     }
828     if (trustlist != NULL) {
829         for (int i = 0; i < size; ++i) {
830             free(trustlist[i]);
831             trustlist[i] = NULL;
832         }
833         free(trustlist);
834         trustlist = NULL;
835     }
836     return ret;
837 }
838 
RpcWpaGetNetwork(RpcServer * server,Context * context)839 int RpcWpaGetNetwork(RpcServer *server, Context *context)
840 {
841     if (server == NULL || context == NULL) {
842         return HAL_FAILURE;
843     }
844     GetNetworkConfig conf = {0};
845     if (ReadInt(context, &(conf.networkId)) < 0 || ReadStr(context, conf.param, sizeof(conf.param)) != 0) {
846         return HAL_FAILURE;
847     }
848     WifiErrorNo err = WpaGetNetWork(&conf);
849     WriteBegin(context, 0);
850     WriteInt(context, err);
851     if (err == 0) {
852         WriteStr(context, conf.value);
853     }
854     WriteEnd(context);
855     return HAL_SUCCESS;
856 }
857 
RpcWpaAutoConnect(RpcServer * server,Context * context)858 int RpcWpaAutoConnect(RpcServer *server, Context *context)
859 {
860     if (server == NULL || context == NULL) {
861         return HAL_FAILURE;
862     }
863     int enable = 0;
864     if (ReadInt(context, &enable) < 0) {
865         return HAL_FAILURE;
866     }
867     WifiErrorNo err = WpaAutoConnect(enable);
868     WriteBegin(context, 0);
869     WriteInt(context, err);
870     WriteEnd(context);
871     return HAL_SUCCESS;
872 }
873 
RpcWpaBlocklistClear(RpcServer * server,Context * context)874 int RpcWpaBlocklistClear(RpcServer *server, Context *context)
875 {
876     if (server == NULL || context == NULL) {
877         return HAL_FAILURE;
878     }
879     WifiErrorNo err = WpaBlocklistClear();
880     WriteBegin(context, 0);
881     WriteInt(context, err);
882     WriteEnd(context);
883     return HAL_SUCCESS;
884 }
885 
RpcGetNetworkList(RpcServer * server,Context * context)886 int RpcGetNetworkList(RpcServer *server, Context *context)
887 {
888     if (server == NULL || context == NULL) {
889         return HAL_FAILURE;
890     }
891     int maxSize = 0;
892     if (ReadInt(context, &maxSize) < 0) {
893         return HAL_FAILURE;
894     }
895     if (maxSize <= 0 || maxSize > WIFI_IDL_GET_MAX_NETWORK_LIST) {
896         return HAL_FAILURE;
897     }
898 
899     WifiNetworkInfo *infos = (WifiNetworkInfo *)calloc(maxSize, sizeof(WifiNetworkInfo));
900     if (infos == NULL) {
901         return HAL_FAILURE;
902     }
903 
904     WifiErrorNo err = GetNetworkList(infos, &maxSize);
905     WriteBegin(context, 0);
906     WriteInt(context, err);
907     if (err == WIFI_HAL_SUCCESS) {
908         WriteInt(context, maxSize);
909         for (int i = 0; i < maxSize; ++i) {
910             WriteInt(context, infos[i].id);
911             WriteStr(context, infos[i].ssid);
912             WriteStr(context, infos[i].bssid);
913             WriteStr(context, infos[i].flags);
914         }
915     }
916     WriteEnd(context);
917     free(infos);
918     infos = NULL;
919     return HAL_SUCCESS;
920 }
921 
RpcGetConnectSignalInfo(RpcServer * server,Context * context)922 int RpcGetConnectSignalInfo(RpcServer *server, Context *context)
923 {
924     if (server == NULL || context == NULL) {
925         return HAL_FAILURE;
926     }
927     char endBssid[WIFI_BSSID_LENGTH] = {0};
928     if (ReadStr(context, endBssid, sizeof(endBssid)) != 0) {
929         return HAL_FAILURE;
930     }
931     WpaSignalInfo info = {0};
932     WifiErrorNo err = GetConnectSignalInfo(endBssid, &info);
933     WriteBegin(context, 0);
934     WriteInt(context, err);
935     if (err == WIFI_HAL_SUCCESS) {
936         WriteInt(context, info.signal);
937         WriteInt(context, info.txrate);
938         WriteInt(context, info.rxrate);
939         WriteInt(context, info.noise);
940         WriteInt(context, info.frequency);
941         WriteInt(context, info.txPackets);
942         WriteInt(context, info.rxPackets);
943         WriteInt(context, info.snr);
944         WriteInt(context, info.chload);
945         WriteInt(context, info.ulDelay);
946         WriteInt(context, info.txBytes);
947         WriteInt(context, info.rxBytes);
948         WriteInt(context, info.txFailed);
949     }
950     WriteEnd(context);
951     return HAL_SUCCESS;
952 }
953 
RpcSetSuspendMode(RpcServer * server,Context * context)954 int RpcSetSuspendMode(RpcServer *server, Context *context)
955 {
956     if (server == NULL || context == NULL) {
957         return HAL_FAILURE;
958     }
959     int tmpMode = 0;
960     if (ReadInt(context, &tmpMode) < 0) {
961         return HAL_FAILURE;
962     }
963     bool mode = (tmpMode == 0) ? false : true;
964     WifiErrorNo err = SetSuspendMode(mode);
965     WriteBegin(context, 0);
966     WriteInt(context, err);
967     WriteEnd(context);
968     return HAL_SUCCESS;
969 }
970 
RpcSetPowerMode(RpcServer * server,Context * context)971 int RpcSetPowerMode(RpcServer *server, Context *context)
972 {
973     if (server == NULL || context == NULL) {
974         return HAL_FAILURE;
975     }
976     int tmpMode = 0;
977     if (ReadInt(context, &tmpMode) < 0) {
978         return HAL_FAILURE;
979     }
980     bool mode = (tmpMode == 0) ? false : true;
981     WifiErrorNo err = SetPowerMode(mode);
982     WriteBegin(context, 0);
983     WriteInt(context, err);
984     WriteEnd(context);
985     return HAL_SUCCESS;
986 }
987