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