1 /*
2 * Copyright (c) 2020 HiSilicon (Shanghai) Technologies CO., LIMITED.
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 #include "at_wifi.h"
16
17 #include <stdio.h>
18 #include <stdlib.h>
19
20 #include <hi_at.h>
21
22 #ifndef CONFIG_FACTORY_TEST_MODE
23 #include "lwip/netifapi.h"
24 #endif
25 #include "hi_early_debug.h"
26 #include "hi_stdlib.h"
27 #include "hi_wifi_api.h"
28 #include "hi_wifi_mfg_test_if.h"
29 #ifdef LOSCFG_APP_MESH
30 #include "hi_wifi_mesh_api.h"
31 #include "hi_mesh_autolink_api.h"
32 #endif
33
34 #include "at.h"
35 #ifndef CONFIG_FACTORY_TEST_MODE
36 #include "lwip/netifapi.h"
37 #include "lwip/dns.h"
38 #endif
39 #include "hi_wifi_mfg_test_if.h"
40 #include "at_demo_hks.h"
41 #include "at_general.h"
42
43 #ifdef __cplusplus
44 #if __cplusplus
45 extern "C" {
46 #endif
47 #endif
48
49 hi_wifi_bw g_bw_setup_value = HI_WIFI_BW_LEGACY_20M;
50 #ifdef _PRE_PSK_CALC_USER
51 unsigned char g_psk_calc[HI_WIFI_STA_PSK_LEN] = {0};
52 #endif
53 hi_wifi_sta_psk_config g_set_psk_config = {
54 .ssid = {0},
55 .key = {0}
56 };
57
ssid_prefix_scan(hi_s32 argc,const hi_char * argv[],hi_u32 prefix_flag)58 hi_u32 ssid_prefix_scan(hi_s32 argc, const hi_char *argv[], hi_u32 prefix_flag)
59 {
60 hi_s32 ret;
61 errno_t rc;
62 char *tmp = HI_NULL;
63 size_t ssid_len = 0;
64 hi_wifi_scan_params scan_params = {0};
65
66 if ((argc != 1) || (at_param_null_check(argc, argv) == HI_ERR_FAILURE)) {
67 return HI_ERR_FAILURE;
68 }
69
70 /* get ssid */
71 if (argv[0][0] == 'P') {
72 if (strlen(argv[0]) > HI_WIFI_MAX_SSID_LEN * 4 + 3) { /* ssid length should less than 32*4+3 */
73 return HI_ERR_FAILURE;
74 }
75 } else {
76 if (strlen(argv[0]) > HI_WIFI_MAX_SSID_LEN + 2) { /* ssid length should less than 32+2 */
77 return HI_ERR_FAILURE;
78 }
79 }
80 /* ssid hex to string */
81 tmp = at_parse_string(argv[0], &ssid_len);
82 scan_params.ssid_len = (unsigned char)ssid_len;
83 if (tmp == HI_NULL) {
84 return HI_ERR_FAILURE;
85 }
86 if ((scan_params.ssid_len > HI_WIFI_MAX_SSID_LEN) || (scan_params.ssid_len == 0)) {
87 at_free(tmp);
88 return HI_ERR_FAILURE;
89 }
90 rc = memcpy_s(scan_params.ssid, HI_WIFI_MAX_SSID_LEN + 1, tmp, strlen(tmp) + 1);
91 at_free(tmp);
92 if (rc != EOK) {
93 return HI_ERR_FAILURE;
94 }
95
96 scan_params.ssid[scan_params.ssid_len] = '\0';
97
98 scan_params.scan_type = (prefix_flag == 1) ? HI_WIFI_SSID_PREFIX_SCAN : HI_WIFI_SSID_SCAN;
99
100 ret = hi_wifi_sta_advance_scan(&scan_params);
101 if (ret != HISI_OK) {
102 return HI_ERR_FAILURE;
103 }
104
105 hi_at_printf("OK\r\n");
106 return HI_ERR_SUCCESS;
107 }
108
109
110 /*****************************************************************************
111 * Func description: wpa ssid scan
112 *****************************************************************************/
cmd_wpa_ssid_scan(hi_s32 argc,const hi_char * argv[])113 hi_u32 cmd_wpa_ssid_scan(hi_s32 argc, const hi_char *argv[])
114 {
115 hi_u32 ret = ssid_prefix_scan(argc, argv, 0);
116 return ret;
117 }
118
119 /*****************************************************************************
120 * Func description: wpa channel scan
121 *****************************************************************************/
cmd_wpa_channel_scan(hi_s32 argc,const hi_char * argv[])122 hi_u32 cmd_wpa_channel_scan(hi_s32 argc, const hi_char *argv[])
123 {
124 hi_s32 ret;
125 hi_wifi_scan_params scan_params = {0};
126
127 if ((argc != 1) || (integer_check(argv[0]) != HI_ERR_SUCCESS)) {
128 return HI_ERR_FAILURE;
129 }
130
131 scan_params.channel = (hi_uchar)atoi(argv[0]);
132 if ((scan_params.channel < 1) || (scan_params.channel > 14)) { /* 信道范围1~14 */
133 return HI_ERR_FAILURE;
134 }
135 scan_params.scan_type = HI_WIFI_CHANNEL_SCAN;
136 ret = hi_wifi_sta_advance_scan(&scan_params);
137 if (ret != HISI_OK) {
138 return HI_ERR_FAILURE;
139 }
140
141 hi_at_printf("OK\r\n");
142 return HI_ERR_SUCCESS;
143 }
144
145 /*****************************************************************************
146 * Func description: wpa scan
147 *****************************************************************************/
cmd_wpa_scan(hi_s32 argc,const hi_char * argv[])148 hi_u32 cmd_wpa_scan(hi_s32 argc, const hi_char *argv[])
149 {
150 hi_s32 ret;
151
152 hi_unref_param(argc);
153 hi_unref_param(argv);
154
155 ret = hi_wifi_sta_scan();
156 if (ret != HISI_OK) {
157 return HI_ERR_FAILURE;
158 }
159
160 hi_at_printf("OK\r\n");
161 return HI_ERR_SUCCESS;
162 }
163
164 /*****************************************************************************
165 * Func description: ssid prefix scan
166 * example: AT+SCANPRSSID="hisi"
167 *****************************************************************************/
cmd_ssid_prefix_scan(hi_s32 argc,const hi_char * argv[])168 hi_u32 cmd_ssid_prefix_scan(hi_s32 argc, const hi_char *argv[])
169 {
170 hi_u32 ret = ssid_prefix_scan(argc, argv, 1);
171 return ret;
172 }
173
at_check_ccharacter(const hi_char * tmp)174 hi_u32 at_check_ccharacter(const hi_char *tmp)
175 {
176 if (tmp == HI_NULL) {
177 return HI_ERR_FAILURE;
178 }
179 for (; *tmp != '\0'; tmp++) {
180 if (*tmp == '\\') {
181 if (*(tmp + 1) == '\\') {
182 tmp++;
183 continue;
184 } else if (*(tmp + 1) == 'x') {
185 return HI_ERR_SUCCESS;
186 }
187 }
188 }
189 return HI_ERR_FAILURE;
190 }
191
192 /*****************************************************************************
193 * Func description: wpa get scan results
194 *****************************************************************************/
cmd_wpa_scan_results(hi_s32 argc,const hi_char * argv[])195 hi_u32 cmd_wpa_scan_results(hi_s32 argc, const hi_char *argv[])
196 {
197 hi_u32 num = WIFI_SCAN_AP_LIMIT;
198 hi_char ssid_str[HI_WIFI_MAX_SSID_LEN * 4 + 3]; /* ssid length should less 32*4+3 */
199
200 hi_unref_param(argv);
201 hi_unref_param(argc);
202
203 hi_wifi_ap_info *results = malloc(sizeof(hi_wifi_ap_info) * WIFI_SCAN_AP_LIMIT);
204 if (results == HI_NULL) {
205 return HI_ERR_FAILURE;
206 }
207
208 memset_s(results, sizeof(hi_wifi_ap_info) * WIFI_SCAN_AP_LIMIT, 0, sizeof(hi_wifi_ap_info) * WIFI_SCAN_AP_LIMIT);
209
210 hi_s32 ret = hi_wifi_sta_scan_results(results, &num);
211 if (ret != HISI_OK) {
212 free(results);
213 return HI_ERR_FAILURE;
214 }
215
216 for (hi_u32 ul_loop = 0; (ul_loop < num) && (ul_loop < WIFI_SCAN_AP_LIMIT); ul_loop++) {
217 if ((results[ul_loop].auth < HI_WIFI_SECURITY_OPEN) || (results[ul_loop].auth > HI_WIFI_SECURITY_UNKNOWN)) {
218 results[ul_loop].auth = HI_WIFI_SECURITY_UNKNOWN;
219 }
220
221 hi_u32 service_flag = 0;
222 if (results[ul_loop].wps_flag) {
223 service_flag = 1;
224 } else if (results[ul_loop].hisi_mesh_flag) {
225 service_flag = 2; /* 2:Mesh scenario.CNcomment:Mesh场景 */
226 }
227
228 size_t ssid_len = strlen(results[ul_loop].ssid);
229 const char* tmp = at_ssid_txt((unsigned char*)results[ul_loop].ssid, ssid_len);
230 if (at_check_ccharacter(tmp) == HI_ERR_SUCCESS) {
231 ret = sprintf_s(ssid_str, HI_WIFI_MAX_SSID_LEN * 4 + 3, "P\"%s\"", tmp); /* ssid len should less 32*4+3 */
232 } else {
233 ret = sprintf_s(ssid_str, HI_WIFI_MAX_SSID_LEN * 4 + 3, "%s", results[ul_loop].ssid); /* less 32*4+3 */
234 }
235 if (ret < 0) {
236 free(results);
237 return HI_ERR_FAILURE;
238 }
239
240 if (service_flag != 0) {
241 hi_at_printf("+SCANRESULT:%s,"AT_MACSTR",%d,%d,%d,%d\r\n", ssid_str, at_mac2str(results[ul_loop].bssid),
242 results[ul_loop].channel, results[ul_loop].rssi / 100, results[ul_loop].auth, service_flag);
243 } else {
244 hi_at_printf("+SCANRESULT:%s,"AT_MACSTR",%d,%d,%d\r\n", ssid_str, at_mac2str(results[ul_loop].bssid),
245 results[ul_loop].channel, results[ul_loop].rssi / 100, results[ul_loop].auth);
246 }
247 }
248
249 free(results);
250
251 hi_at_printf("OK\r\n");
252 return HI_ERR_SUCCESS;
253 }
254
255 /*****************************************************************************
256 * Func description: start sta
257 *****************************************************************************/
cmd_sta_start(hi_s32 argc,const hi_char * argv[])258 hi_u32 cmd_sta_start(hi_s32 argc, const hi_char *argv[])
259 {
260 hi_unref_param(argv);
261 hi_unref_param(argc);
262 #ifndef CONFIG_FACTORY_TEST_MODE
263 hi_s32 ret;
264 hi_char ifname[WIFI_IFNAME_MAX_SIZE + 1] = {0};
265 hi_s32 len = sizeof(ifname);
266
267 ret = hi_wifi_sta_start(ifname, &len);
268 if (ret != HISI_OK) {
269 return HI_ERR_FAILURE;
270 }
271 #else
272 if (wal_add_cfg_vap() != HI_ERR_SUCCESS) {
273 return HI_ERR_FAILURE;
274 }
275 #endif
276 hi_at_printf("OK\r\n");
277 return HI_ERR_SUCCESS;
278 }
279
sta_start_adv_param(hi_s32 argc,const hi_char * argv[],hi_wifi_bw * bw)280 hi_u32 sta_start_adv_param(hi_s32 argc, const hi_char *argv[], hi_wifi_bw *bw)
281 {
282 hi_s32 ret, value, i;
283 for (i = 0; i < argc; i++) {
284 if ((argv[i] != HI_NULL) && (integer_check(argv[i]) != HI_ERR_SUCCESS)) {
285 return HI_ERR_FAILURE;
286 }
287 switch (i) {
288 case 0: /* case 0: Protocol Type */
289 value = (argv[i] != HI_NULL) ? atoi(argv[i]) : HI_WIFI_PHY_MODE_11BGN;
290 if ((value == HI_WIFI_PHY_MODE_11B) && (argv[1] != HI_NULL) && (strcmp(argv[1], "20"))) { /* 20:bw */
291 return HI_ERR_FAILURE;
292 }
293 #ifndef CONFIG_FACTORY_TEST_MODE
294 ret = hi_wifi_sta_set_protocol_mode((hi_wifi_protocol_mode)value);
295 #endif
296 break;
297 case 1: /* case 1: Bandwidth */
298 if ((argv[i] == HI_NULL) || !(strcmp(argv[i], "20"))) { /* bw 20M */
299 *bw = HI_WIFI_BW_LEGACY_20M;
300 } else if (!(strcmp(argv[i], "10"))) { /* bw 10M */
301 *bw = HI_WIFI_BW_HIEX_10M;
302 } else if (!(strcmp(argv[i], "5"))) { /* bw 5M */
303 *bw = HI_WIFI_BW_HIEX_5M;
304 } else {
305 return HI_ERR_FAILURE;
306 }
307 ret = HISI_OK;
308 break;
309 case 2: /* case 2: pmf */
310 #ifndef CONFIG_FACTORY_TEST_MODE
311 value = (argv[i] != HI_NULL) ? atoi(argv[i]) : HI_WIFI_MGMT_FRAME_PROTECTION_OPTIONAL;
312 ret = hi_wifi_set_pmf((hi_wifi_pmf_options)value);
313 #endif
314 break;
315 default:
316 return HI_ERR_FAILURE;
317 }
318 #ifndef CONFIG_FACTORY_TEST_MODE
319 if (ret != HISI_OK) {
320 return HI_ERR_FAILURE;
321 }
322 #endif
323 }
324 hi_unref_param(ret);
325 return HI_ERR_SUCCESS;
326 }
327
cmd_sta_start_adv(hi_s32 argc,const hi_char * argv[])328 hi_u32 cmd_sta_start_adv(hi_s32 argc, const hi_char *argv[])
329 {
330 hi_s32 ret;
331 hi_wifi_bw bw = HI_WIFI_BW_LEGACY_20M;
332
333 if (argc != 3) { /* "+STARTSTA" command fix 3 parameters */
334 return HI_ERR_FAILURE;
335 }
336
337 ret = (hi_s32)sta_start_adv_param(argc, argv, &bw);
338 if (ret != HI_ERR_SUCCESS) {
339 return HI_ERR_FAILURE;
340 }
341 #ifndef CONFIG_FACTORY_TEST_MODE
342 hi_char ifname[WIFI_IFNAME_MAX_SIZE + 1] = {0};
343 hi_s32 len = sizeof(ifname);
344 ret = hi_wifi_sta_start(ifname, &len);
345 if (ret != HISI_OK) {
346 return HI_ERR_FAILURE;
347 }
348 #endif
349 ret = hi_wifi_set_bandwidth(DEFAULT_IFNAME_STA, strlen(DEFAULT_IFNAME_STA) + 1, bw);
350 if (ret != HI_ERR_SUCCESS) {
351 #ifndef CONFIG_FACTORY_TEST_MODE
352 hi_wifi_sta_stop();
353 #endif
354 return HI_ERR_FAILURE;
355 }
356
357 hi_at_printf("OK\r\n");
358 return HI_ERR_SUCCESS;
359 }
360
361 /*****************************************************************************
362 * Func description: stop station
363 *****************************************************************************/
cmd_sta_stop(hi_s32 argc,const hi_char * argv[])364 hi_u32 cmd_sta_stop(hi_s32 argc, const hi_char *argv[])
365 {
366 hi_unref_param(argv);
367 hi_unref_param(argc);
368 #ifndef CONFIG_FACTORY_TEST_MODE
369 hi_s32 ret = hi_wifi_sta_stop();
370 if (ret != HISI_OK) {
371 return HI_ERR_FAILURE;
372 }
373
374 for (int index = 0; index < DNS_MAX_SERVERS; index++) {
375 lwip_dns_setserver(index, HI_NULL);
376 }
377 #endif
378 hi_at_printf("OK\r\n");
379 return HI_ERR_SUCCESS;
380 }
381
cmd_sta_connect_get_ssid(const hi_char * argv[],hi_wifi_assoc_request * assoc_req,hi_wifi_fast_assoc_request * fast_assoc_req,hi_u32 fast_flag)382 hi_u32 cmd_sta_connect_get_ssid(const hi_char *argv[], hi_wifi_assoc_request *assoc_req,
383 hi_wifi_fast_assoc_request *fast_assoc_req, hi_u32 fast_flag)
384 {
385 size_t ssid_len = 0;
386 errno_t rc;
387
388 if (argv[0][0] == 'P') {
389 if (strlen(argv[0]) > HI_WIFI_MAX_SSID_LEN * 4 + 3) { /* ssid length should less than 32*4+3 */
390 return HI_ERR_FAILURE;
391 }
392 } else {
393 if (strlen(argv[0]) > HI_WIFI_MAX_SSID_LEN + 2) { /* ssid length should less than 32+2 */
394 return HI_ERR_FAILURE;
395 }
396 }
397
398 /* ssid hex to string */
399 hi_char *tmp = at_parse_string(argv[0], &ssid_len);
400 if (tmp == HI_NULL) {
401 return HI_ERR_FAILURE;
402 }
403 if ((ssid_len > HI_WIFI_MAX_SSID_LEN) || (ssid_len == 0)) {
404 at_free(tmp);
405 return HI_ERR_FAILURE;
406 }
407
408 if ((fast_flag == 0) && (assoc_req != HI_NULL)) {
409 rc = memcpy_s(assoc_req->ssid, HI_WIFI_MAX_SSID_LEN + 1, tmp, strlen(tmp) + 1);
410 at_free(tmp);
411 if (rc != EOK) {
412 return HI_ERR_FAILURE;
413 }
414 } else if ((fast_flag == 1) && (fast_assoc_req != HI_NULL)) {
415 rc = memcpy_s(fast_assoc_req->req.ssid, HI_WIFI_MAX_SSID_LEN + 1, tmp, strlen(tmp) + 1);
416 at_free(tmp);
417 if (rc != EOK) {
418 return HI_ERR_FAILURE;
419 }
420 } else {
421 at_free(tmp);
422 }
423 return HI_ERR_SUCCESS;
424 }
425
cmd_sta_connect_get_key(hi_s32 argc,const hi_char * argv[],hi_wifi_fast_assoc_request * fast_assoc_req)426 hi_u32 cmd_sta_connect_get_key(hi_s32 argc, const hi_char *argv[], hi_wifi_fast_assoc_request *fast_assoc_req)
427 {
428 if ((fast_assoc_req->req.auth != HI_WIFI_SECURITY_OPEN) && (argc == 5)) { /* 5 parameters */
429 if (argv[4] == HI_NULL) { /* 4:key */
430 return HI_ERR_FAILURE;
431 }
432 const hi_char *buf = argv[4]; /* 4:key */
433
434 size_t len = strlen(argv[4]); /* 4:key */
435 if ((atoi(argv[3]) == HI_WIFI_SECURITY_WEP) && (len != 9) && (len != 17) && /* 3:encrypt type, 9 17:len */
436 (len != 12) && (len != 28)) { /* 12 28: password len */
437 return HI_ERR_FAILURE;
438 } else if ((atoi(argv[3]) != HI_WIFI_SECURITY_WEP) && ((len > HI_WIFI_AP_KEY_LEN_MAX + 2) || /* argc 3,2 */
439 (len < HI_WIFI_AP_KEY_LEN_MIN + 2))) { /* len plus 2 */
440 return HI_ERR_FAILURE;
441 }
442 if ((buf == HI_NULL) || (*buf != '\"') || (*(buf + strlen(argv[4]) - 1) != '\"') || /* 4 */
443 (memcpy_s(fast_assoc_req->req.key, HI_WIFI_MAX_KEY_LEN + 1, buf + 1, strlen(argv[4]) - 2) /* 4 2 */
444 != EOK)) {
445 return HI_ERR_FAILURE;
446 }
447 }
448 fast_assoc_req->psk_flag = HI_WIFI_WPA_PSK_NOT_USE;
449
450 return HI_ERR_SUCCESS;
451 }
452
parse_conn_para(hi_s32 argc,const hi_char * argv[],hi_wifi_assoc_request * assoc_req)453 hi_u32 parse_conn_para(hi_s32 argc, const hi_char *argv[], hi_wifi_assoc_request *assoc_req)
454 {
455 if ((argc < 3) || (argc > 4)) { /* The number of "+CONN" command parameters should be 3 or 4 */
456 return HI_ERR_FAILURE;
457 }
458
459 /* get ssid */
460 if ((argv[0] != HI_NULL) && (cmd_sta_connect_get_ssid(argv, assoc_req, HI_NULL, 0) != HI_ERR_SUCCESS)) {
461 return HI_ERR_FAILURE;
462 }
463
464 /* get bssid */
465 if (argv[1] == HI_NULL) {
466 memset_s(assoc_req->bssid, sizeof(assoc_req->bssid), 0, sizeof(assoc_req->bssid));
467 } else if (strlen(argv[1]) == HI_WIFI_TXT_ADDR_LEN) {
468 if (cmd_strtoaddr(argv[1], assoc_req->bssid, HI_WIFI_MAC_LEN) != HISI_OK) {
469 return HI_ERR_FAILURE;
470 }
471 } else {
472 return HI_ERR_FAILURE;
473 }
474
475 /* get auth_type */
476 if ((integer_check(argv[2]) != HI_ERR_SUCCESS) || (atoi(argv[2]) < HI_WIFI_SECURITY_OPEN) || /* 2 */
477 (atoi(argv[2]) > HI_WIFI_SECURITY_WPAPSK_WPA2PSK_MIX) || ((atoi(argv[2]) == HI_WIFI_SECURITY_OPEN) && /* 2 */
478 (argc != 3)) || ((atoi(argv[2]) != HI_WIFI_SECURITY_OPEN) && (argc != 4))) { /* argc 3/2/4 */
479 return HI_ERR_FAILURE;
480 }
481 assoc_req->auth = (hi_wifi_auth_mode)atoi(argv[2]); /* 2 */
482
483 /* The encipher mode is set to 0 by default, that is, HI_WIFI_PARIWISE_UNKNOWN.
484 CNcomment:encipher mode 默认设置为0，即HI_WIFI_PARIWISE_UNKNOWN */
485 assoc_req->pairwise = HI_WIFI_PARIWISE_UNKNOWN;
486
487 /* get key */
488 if (argc == 4) { /* 4 parameters */
489 const hi_char *buf = argv[3]; /* 3:The fourth parameter */
490 if (buf == HI_NULL) {
491 return HI_ERR_FAILURE;
492 }
493 size_t len = strlen(argv[3]); /* 3:key */
494 if ((atoi(argv[2]) == HI_WIFI_SECURITY_WEP) && (len != 9) && (len != 17) && /* argc 2, len 9/17 */
495 (len != 12) && (len != 28)) { /* len 12/28 */
496 return HI_ERR_FAILURE;
497 } else if ((atoi(argv[2]) != HI_WIFI_SECURITY_WEP) && ((len > HI_WIFI_AP_KEY_LEN_MAX + 2) || /* argc 2 */
498 (len < HI_WIFI_AP_KEY_LEN_MIN + 2))) { /* len plus 2 */
499 return HI_ERR_FAILURE;
500 }
501 if ((*buf != '\"') || (*(buf + strlen(argv[3]) - 1) != '\"') || /* argc 3 */
502 (memcpy_s(assoc_req->key, HI_WIFI_MAX_KEY_LEN + 1, buf + 1, strlen(argv[3]) - 2) != EOK)) { /* 3 2 */
503 return HI_ERR_FAILURE;
504 }
505 }
506
507 return HI_ERR_SUCCESS;
508 }
509
510 /*****************************************************************************
511 * Func description: station connect network
512 * example: AT+CONN="hisilicon",,3,"123456789"
513 *****************************************************************************/
cmd_sta_secure_connect(hi_s32 argc,const hi_char * argv[])514 hi_u32 cmd_sta_secure_connect(hi_s32 argc, const hi_char *argv[])
515 {
516 hi_wifi_assoc_request assoc_req = {0};
517
518 if (parse_conn_para(argc, argv, &assoc_req) != HI_ERR_SUCCESS) {
519 return HI_ERR_FAILURE;
520 }
521
522 if (hi_wifi_sta_connect(&assoc_req) != HISI_OK) {
523 return HI_ERR_FAILURE;
524 }
525
526 hi_u32 ret = app_hks_encrypt_conn_para(&assoc_req);
527 if (ret != HI_ERR_SUCCESS) {
528 hi_at_printf("save enc conn param fail:0x%x\r\n", ret);
529 return HI_ERR_FAILURE;
530 }
531
532 hi_at_printf("OK\r\n");
533 return HI_ERR_SUCCESS;
534 }
535
cmd_sta_secure_re_connect(hi_s32 argc,const hi_char * argv[])536 hi_u32 cmd_sta_secure_re_connect(hi_s32 argc, const hi_char *argv[])
537 {
538 hi_unref_param(argc);
539 hi_unref_param(argv);
540
541 hi_wifi_assoc_request assoc_req = {0};
542
543 hi_u32 ret = app_hks_decrypt_conn_param(&assoc_req);
544 if (ret != HI_ERR_SUCCESS) {
545 hi_at_printf("get reconn param fail:0x%x\r\n", ret);
546 return HI_ERR_FAILURE;
547 }
548 hi_at_printf("get reconn param ok\r\n");
549
550 if (hi_wifi_sta_connect(&assoc_req) != HISI_OK) {
551 return HI_ERR_FAILURE;
552 }
553
554 hi_at_printf("OK\r\n");
555 return HI_ERR_SUCCESS;
556 }
557
cmd_generate_save_conn_key(hi_s32 argc,const hi_char * argv[])558 hi_u32 cmd_generate_save_conn_key(hi_s32 argc, const hi_char *argv[])
559 {
560 hi_unref_param(argc);
561 hi_unref_param(argv);
562
563 hi_u32 ret = app_hks_generate_conn_key();
564 if (ret != HI_ERR_SUCCESS) {
565 hi_at_printf("generate conn key fail:0x%x\r\n", ret);
566 return HI_ERR_FAILURE;
567 }
568
569 hi_at_printf("generate conn key ok\r\n");
570 hi_at_printf("OK\r\n");
571 return HI_ERR_SUCCESS;
572 }
573
cmd_generate_save_cert_key(hi_s32 argc,const hi_char * argv[])574 hi_u32 cmd_generate_save_cert_key(hi_s32 argc, const hi_char *argv[])
575 {
576 hi_unref_param(argc);
577 hi_unref_param(argv);
578
579 hi_u32 ret = app_hks_generate_cert_key();
580 if (ret != HI_ERR_SUCCESS) {
581 hi_at_printf("generate cert key fail\r\n");
582 return HI_ERR_FAILURE;
583 }
584
585 hi_at_printf("generate cert key ok\r\n");
586 hi_at_printf("OK\r\n");
587 return HI_ERR_SUCCESS;
588 }
589
cmd_encrypt_cert(hi_s32 argc,const hi_char * argv[])590 hi_u32 cmd_encrypt_cert(hi_s32 argc, const hi_char *argv[])
591 {
592 hi_unref_param(argc);
593 hi_unref_param(argv);
594
595 hi_u32 ret = app_hks_encrypt_cert();
596 if (ret != HI_ERR_SUCCESS) {
597 hi_at_printf("encrpyt cert fail\r\n");
598 return HI_ERR_FAILURE;
599 }
600 hi_at_printf("encrpyt cert success\r\n");
601
602 hi_at_printf("OK\r\n");
603 return HI_ERR_SUCCESS;
604 }
605
606 #define CERT_PLAIN_SIZE (1024*8)
607
cmd_decrypt_cert(hi_s32 argc,const hi_char * argv[])608 hi_u32 cmd_decrypt_cert(hi_s32 argc, const hi_char *argv[])
609 {
610 hi_unref_param(argc);
611 hi_unref_param(argv);
612
613 hi_u32 plain_size = CERT_PLAIN_SIZE;
614 hi_u8 *plain_data = malloc(plain_size);
615 if (plain_data == HI_NULL) {
616 hi_at_printf("plain data malloc fail\r\n");
617 return HI_ERR_FAILURE;
618 }
619
620 hi_u32 ret = app_hks_decrypt_cert(&plain_size, plain_data);
621 if (ret != HI_ERR_SUCCESS) {
622 free(plain_data);
623 hi_at_printf("decrpyt cert fail:0x%x\r\n", ret);
624 return HI_ERR_FAILURE;
625 }
626
627 hi_at_printf("decrpyt cert success, plain_size:%d\r\n", plain_size);
628 hi_u32 print_size = 0x40;
629 if (plain_size < print_size) {
630 print_size = plain_size;
631 }
632 for (hi_u32 i = 1; i <= print_size; i++) {
633 hi_at_printf("0x%x ", plain_data[i - 1]);
634 if (i % 0x4 == 0) {
635 hi_at_printf("\r\n");
636 }
637 }
638
639 free(plain_data);
640
641 hi_at_printf("OK\r\n");
642 return HI_ERR_SUCCESS;
643 }
644
645 /*****************************************************************************
646 * Func description: station connect network
647 * example: AT+CONN="hisilicon",,3,"123456789"
648 *****************************************************************************/
cmd_sta_connect(hi_s32 argc,const hi_char * argv[])649 hi_u32 cmd_sta_connect(hi_s32 argc, const hi_char *argv[])
650 {
651 hi_wifi_assoc_request assoc_req = {0};
652
653 if ((argc < 3) || (argc > 4)) { /* argc 3/4 */
654 return HI_ERR_FAILURE;
655 }
656
657 /* get ssid */
658 if ((argv[0] != HI_NULL) && (cmd_sta_connect_get_ssid(argv, &assoc_req, HI_NULL, 0) != HI_ERR_SUCCESS)) {
659 return HI_ERR_FAILURE;
660 }
661
662 /* get bssid */
663 if (argv[1] == HI_NULL) {
664 memset_s(assoc_req.bssid, sizeof(assoc_req.bssid), 0, sizeof(assoc_req.bssid));
665 } else if (strlen(argv[1]) == HI_WIFI_TXT_ADDR_LEN) {
666 if (cmd_strtoaddr(argv[1], assoc_req.bssid, HI_WIFI_MAC_LEN) != HISI_OK) {
667 return HI_ERR_FAILURE;
668 }
669 } else {
670 return HI_ERR_FAILURE;
671 }
672
673 /* get auth_type */
674 if ((integer_check(argv[2]) != HI_ERR_SUCCESS) || (atoi(argv[2]) < HI_WIFI_SECURITY_OPEN) || /* argc 2 */
675 (atoi(argv[2]) == HI_WIFI_SECURITY_WPA) || (atoi(argv[2]) == HI_WIFI_SECURITY_WPA2) || /* argc 2 */
676 (atoi(argv[2]) == HI_WIFI_SECURITY_WPAPSK) || (atoi(argv[2]) >= HI_WIFI_SECURITY_UNKNOWN) || /* argc 2 */
677 ((atoi(argv[2]) == HI_WIFI_SECURITY_OPEN) && (argc != 3)) || /* argc 2/3/4 */
678 ((atoi(argv[2]) != HI_WIFI_SECURITY_OPEN) && (argc != 4))) { /* argc 2/3/4 */
679 return HI_ERR_FAILURE;
680 }
681 assoc_req.auth = (hi_wifi_auth_mode)atoi(argv[2]); /* 2 */
682
683 assoc_req.pairwise = HI_WIFI_PARIWISE_UNKNOWN;
684
685 /* get key */
686 if (argc == 4) { /* argc 4 */
687 const hi_char *buf = argv[3]; /* argc 3 */
688 if (buf == HI_NULL) {
689 return HI_ERR_FAILURE;
690 }
691 size_t len = strlen(argv[3]); /* 3:key */
692 if ((atoi(argv[2]) == HI_WIFI_SECURITY_WEP) && (len != 9) && (len != 17) && /* argc 2, len 9/17 */
693 (len != 12) && (len != 28)) { /* 12 28: password len */
694 return HI_ERR_FAILURE;
695 } else if ((atoi(argv[2]) != HI_WIFI_SECURITY_WEP) && ((len > HI_WIFI_AP_KEY_LEN_MAX + 2) || /* argc 2 */
696 (len < HI_WIFI_AP_KEY_LEN_MIN + 2))) { /* len plus 2 */
697 return HI_ERR_FAILURE;
698 }
699 if ((*buf != '\"') || (*(buf + strlen(argv[3]) - 1) != '\"') || /* argc 3 */
700 (memcpy_s(assoc_req.key, HI_WIFI_MAX_KEY_LEN + 1, buf + 1, strlen(argv[3]) - 2) != EOK)) { /* 3 2 */
701 return HI_ERR_FAILURE;
702 }
703 }
704
705 if (hi_wifi_sta_connect(&assoc_req) != HISI_OK) {
706 return HI_ERR_FAILURE;
707 }
708
709 hi_at_printf("OK\r\n");
710 return HI_ERR_SUCCESS;
711 }
712
713 /*****************************************************************************
714 * Func description: station quick connect
715 * example: AT+FCONN="hisilicon",,6,2,"123456789"
716 AT+FCONN=,90:2B:D2:E4:CE:28,6,2,"123456789"
717 *****************************************************************************/
cmd_sta_quick_connect(hi_s32 argc,const hi_char * argv[])718 hi_u32 cmd_sta_quick_connect(hi_s32 argc, const hi_char *argv[])
719 {
720 hi_wifi_fast_assoc_request fast_assoc_req = {0};
721 hi_u32 ret;
722
723 if ((argc < 4) || (argc > 5)) { /* argc 4 / 5 */
724 return HI_ERR_FAILURE;
725 }
726
727 /* get ssid */
728 if (argv[0] != HI_NULL) {
729 ret = cmd_sta_connect_get_ssid(argv, HI_NULL, &fast_assoc_req, 1);
730 if (ret != HI_ERR_SUCCESS) {
731 return HI_ERR_FAILURE;
732 }
733 }
734
735 /* get bssid */
736 if (argv[1] == HI_NULL) {
737 memset_s(fast_assoc_req.req.bssid, sizeof(fast_assoc_req.req.bssid), 0, sizeof(fast_assoc_req.req.bssid));
738 } else if (strlen(argv[1]) == HI_WIFI_TXT_ADDR_LEN) {
739 if (cmd_strtoaddr(argv[1], fast_assoc_req.req.bssid, HI_WIFI_MAC_LEN) != HISI_OK) {
740 return HI_ERR_FAILURE;
741 }
742 } else {
743 return HI_ERR_FAILURE;
744 }
745
746 /* get channel,Scope1~14 */
747 if ((integer_check(argv[2]) != HI_ERR_SUCCESS) || (atoi(argv[2]) <= 0) || (atoi(argv[2]) > 14)) { /* 2 14 */
748 return HI_ERR_FAILURE;
749 }
750 fast_assoc_req.channel = (hi_uchar)atoi(argv[2]); /* 2 */
751
752 /* get auth_type */
753 if ((integer_check(argv[3]) != HI_ERR_SUCCESS) || (atoi(argv[3]) < HI_WIFI_SECURITY_OPEN) || /* argv 3 */
754 (atoi(argv[3]) == HI_WIFI_SECURITY_WPA) || (atoi(argv[3]) == HI_WIFI_SECURITY_WPA2) || /* argv 3 */
755 (atoi(argv[3]) == HI_WIFI_SECURITY_WPAPSK) || (atoi(argv[3]) >= HI_WIFI_SECURITY_UNKNOWN) || /* argv 3 */
756 ((atoi(argv[3]) == HI_WIFI_SECURITY_OPEN) && (argc != 4)) || /* argc 3/4/5 */
757 ((atoi(argv[3]) != HI_WIFI_SECURITY_OPEN) && (argc != 5))) { /* argc 3/4/5 */
758 return HI_ERR_FAILURE;
759 }
760
761 fast_assoc_req.req.auth = (hi_wifi_auth_mode)atoi(argv[3]); /* 3 */
762
763 /* get encipher mode 0，HI_WIFI_PARIWISE_UNKNOWN */
764 fast_assoc_req.req.pairwise = HI_WIFI_PARIWISE_UNKNOWN;
765
766 /* get key */
767 ret = cmd_sta_connect_get_key(argc, argv, &fast_assoc_req);
768 if (ret != HI_ERR_SUCCESS) {
769 return HI_ERR_FAILURE;
770 }
771
772 if (hi_wifi_sta_fast_connect(&fast_assoc_req) != HISI_OK) {
773 return HI_ERR_FAILURE;
774 }
775
776 hi_at_printf("OK\r\n");
777 return HI_ERR_SUCCESS;
778 }
779
780 /*****************************************************************************
781 * Func description: sta disconnect network
782 *****************************************************************************/
cmd_sta_disconnect(hi_s32 argc,const hi_char * argv[])783 hi_u32 cmd_sta_disconnect(hi_s32 argc, const hi_char *argv[])
784 {
785 hi_unref_param(argv);
786 hi_unref_param(argc);
787
788 hi_s32 ret = hi_wifi_sta_disconnect();
789 if (ret != HISI_OK) {
790 return HI_ERR_FAILURE;
791 }
792
793 hi_at_printf("OK\r\n");
794 return HI_ERR_SUCCESS;
795 }
796
797 /*****************************************************************************
798 * Func description: get station connection status
799 *****************************************************************************/
cmd_sta_status(hi_s32 argc,const hi_char * argv[])800 hi_u32 cmd_sta_status(hi_s32 argc, const hi_char *argv[])
801 {
802 hi_s32 ret;
803 hi_wifi_status wifi_status;
804
805 hi_unref_param(argv);
806 hi_unref_param(argc);
807
808 memset_s(&wifi_status, sizeof(hi_wifi_status), 0, sizeof(hi_wifi_status));
809
810 ret = hi_wifi_sta_get_connect_info(&wifi_status);
811 if (ret != HISI_OK) {
812 return HI_ERR_FAILURE;
813 }
814 if (wifi_status.status == HI_WIFI_CONNECTED) {
815 const hi_char *tmp = at_ssid_txt((unsigned char*)wifi_status.ssid, strlen(wifi_status.ssid));
816 if (at_check_ccharacter(tmp) == HI_ERR_SUCCESS) {
817 hi_at_printf("+STASTAT:1,P\"%s\","AT_MACSTR",%d\r\n", tmp, at_mac2str(wifi_status.bssid),
818 wifi_status.channel);
819 } else {
820 hi_at_printf("+STASTAT:1,%s,"AT_MACSTR",%d\r\n", wifi_status.ssid, at_mac2str(wifi_status.bssid),
821 wifi_status.channel);
822 }
823 } else {
824 hi_at_printf("+STASTAT:0,0,0,0\r\n");
825 }
826 hi_at_printf("OK\r\n");
827 return HI_ERR_SUCCESS;
828 }
829
830 #ifdef CONFIG_WPS_SUPPORT
831 /*****************************************************************************
832 * Func description: using wps pbc to connect network
833 * example: sta wps_pbc <bssid>
834 *****************************************************************************/
cmd_wpa_wps_pbc(hi_s32 argc,const hi_char * argv[])835 hi_u32 cmd_wpa_wps_pbc(hi_s32 argc, const hi_char *argv[])
836 {
837 hi_unref_param(argv);
838 hi_unref_param(argc);
839
840 hi_s32 ret = hi_wifi_sta_wps_pbc(HI_NULL);
841 if (ret != HISI_OK) {
842 return HI_ERR_FAILURE;
843 }
844
845 hi_at_printf("OK\r\n");
846 return HI_ERR_SUCCESS;
847 }
848
849 /*****************************************************************************
850 * Func description: get wps pin value
851 *****************************************************************************/
cmd_wpa_wps_pin_get(hi_s32 argc,const hi_char * argv[])852 hi_u32 cmd_wpa_wps_pin_get(hi_s32 argc, const hi_char *argv[])
853 {
854 hi_char pin_txt[WIFI_WPS_PIN_LEN + 1] = {0};
855 hi_u32 len = WIFI_WPS_PIN_LEN + 1;
856 hi_s32 ret;
857
858 hi_unref_param(argv);
859 hi_unref_param(argc);
860
861 ret = hi_wifi_sta_wps_pin_get(pin_txt, len);
862 if (ret != HISI_OK) {
863 return HI_ERR_FAILURE;
864 }
865 pin_txt[WIFI_WPS_PIN_LEN] = '\0';
866
867 hi_at_printf("+PINSHOW:%s\r\n", pin_txt);
868 hi_at_printf("OK\r\n");
869 return HI_ERR_SUCCESS;
870 }
871
872 /*****************************************************************************
873 * Func description: using wps pin to connect network
874 * example: AT+PIN=03882368
875 *****************************************************************************/
cmd_wpa_wps_pin(hi_s32 argc,const hi_char * argv[])876 hi_u32 cmd_wpa_wps_pin(hi_s32 argc, const hi_char *argv[])
877 {
878 hi_char pin[WIFI_WPS_PIN_LEN + 1] = {0};
879 hi_char *ppin = pin;
880
881 if ((argc != 1) || (at_param_null_check(argc, argv) == HI_ERR_FAILURE)) {
882 return HI_ERR_FAILURE;
883 }
884
885 hi_u32 len = strlen(argv[0]);
886 if ((len != WIFI_WPS_PIN_LEN) || (memcpy_s(pin, WIFI_WPS_PIN_LEN + 1, argv[0], len) != EOK)) {
887 return HI_ERR_FAILURE;
888 }
889
890 if (hi_wifi_sta_wps_pin(ppin, HI_NULL) != HISI_OK) {
891 return HI_ERR_FAILURE;
892 }
893
894 hi_at_printf("OK\r\n");
895 return HI_ERR_SUCCESS;
896 }
897 #endif /* LOSCFG_APP_WPS */
898
cmd_set_reconn(hi_s32 argc,const hi_char * argv[])899 hi_u32 cmd_set_reconn(hi_s32 argc, const hi_char *argv[])
900 {
901 hi_s32 enable;
902 hi_s32 seconds = RECONN_TIMEOUT_MIN;
903 hi_u32 period = RECONN_PERIOD_MIN;
904 hi_u32 max_try_count = RECONN_COUNT_MIN;
905 if ((argc != 1) && (argc != 4)) { /* argc 1/4 */
906 return HI_ERR_FAILURE;
907 }
908 if (argc == 1) {
909 if ((integer_check(argv[0]) != HI_ERR_SUCCESS) || (atoi(argv[0]) != 0)) {
910 return HI_ERR_FAILURE;
911 }
912 enable = 0;
913 } else {
914 for (hi_s32 i = 0; i < argc - 1; i++) {
915 if (integer_check(argv[i]) != HI_ERR_SUCCESS) {
916 return HI_ERR_FAILURE;
917 }
918 }
919 enable = atoi(argv[0]);
920 if (enable == 0) {
921 return HI_ERR_FAILURE;
922 }
923 period = (hi_u32)atoi(argv[1]); /* argc 1 */
924 max_try_count = (hi_u32)atoi(argv[2]); /* argc 2 */
925 if (argv[3] != HI_NULL) { /* argc 3 */
926 if (integer_check(argv[3]) != HI_ERR_SUCCESS) { /* argc 3 */
927 return HI_ERR_FAILURE;
928 }
929 seconds = atoi(argv[3]); /* argc 3 */
930 }
931
932 if (seconds < RECONN_TIMEOUT_MIN || period < RECONN_PERIOD_MIN || period > RECONN_PERIOD_MAX ||
933 max_try_count < RECONN_COUNT_MIN || max_try_count > RECONN_COUNT_MAX) {
934 return HI_ERR_FAILURE;
935 }
936 }
937 hi_s32 ret = hi_wifi_sta_set_reconnect_policy(enable, seconds, period, max_try_count);
938 if (ret != HISI_OK) {
939 return HI_ERR_FAILURE;
940 }
941
942 hi_at_printf("OK\r\n");
943
944 return HI_ERR_SUCCESS;
945 }
946
947 const at_cmd_func g_sta_func_tbl[] = {
948 {"+STOPSTA", 8, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_stop},
949 {"+SCAN", 5, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_wpa_scan},
950 {"+SCANCHN", 8, HI_NULL, HI_NULL, (at_call_back_func)cmd_wpa_channel_scan, HI_NULL},
951 {"+SCANSSID", 9, HI_NULL, HI_NULL, (at_call_back_func)cmd_wpa_ssid_scan, HI_NULL},
952 {"+SCANPRSSID", 11, HI_NULL, HI_NULL, (at_call_back_func)cmd_ssid_prefix_scan, HI_NULL},
953 {"+SCANRESULT", 11, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_wpa_scan_results},
954 {"+CONN", 5, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_connect, HI_NULL},
955 {"+FCONN", 6, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_quick_connect, HI_NULL},
956 {"+DISCONN", 8, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_disconnect},
957 {"+STASTAT", 8, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_status},
958 {"+RECONN", 7, HI_NULL, HI_NULL, (at_call_back_func)cmd_set_reconn, HI_NULL},
959 #ifdef CONFIG_WPS_SUPPORT
960 {"+PBC", 4, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_wpa_wps_pbc},
961 {"+PIN", 4, HI_NULL, HI_NULL, (at_call_back_func)cmd_wpa_wps_pin, HI_NULL},
962 {"+PINSHOW", 8, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_wpa_wps_pin_get},
963 #endif /* LOSCFG_APP_WPS */
964 #ifdef CONFIG_TEE_HUKS_DEMO_SUPPORT
965 {"+GCONNKEY", 9, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_generate_save_conn_key},
966 {"+SCONN", 6, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_secure_connect, HI_NULL},
967 {"+SRCONN", 7, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_secure_re_connect},
968 #endif
969 };
970
971 #define AT_STA_FUNC_NUM (sizeof(g_sta_func_tbl) / sizeof(g_sta_func_tbl[0]))
972
hi_at_sta_cmd_register(hi_void)973 hi_void hi_at_sta_cmd_register(hi_void)
974 {
975 hi_at_register_cmd(g_sta_func_tbl, AT_STA_FUNC_NUM);
976 }
977
978 const at_cmd_func g_sta_factory_test_func_tbl[] = {
979 {"+STARTSTA", 9, HI_NULL, HI_NULL, (at_call_back_func)cmd_sta_start_adv, (at_call_back_func)cmd_sta_start},
980 #ifdef CONFIG_TEE_HUKS_DEMO_SUPPORT
981 {"+GCERTKEY", 9, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_generate_save_cert_key},
982 {"+CERTENC", 8, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_encrypt_cert},
983 {"+CERTDEC", 8, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_decrypt_cert},
984 #endif
985 };
986
987 #define AT_STA_FACTORY_TEST_FUNC_NUM (sizeof(g_sta_factory_test_func_tbl) / sizeof(g_sta_factory_test_func_tbl[0]))
988
hi_at_sta_factory_test_cmd_register(hi_void)989 hi_void hi_at_sta_factory_test_cmd_register(hi_void)
990 {
991 hi_at_register_cmd(g_sta_factory_test_func_tbl, AT_STA_FACTORY_TEST_FUNC_NUM);
992 }
993
994 /*****************************************************************************
995 * Func description: show mesh or softap connected sta information
996 *****************************************************************************/
cmd_softap_show_sta(hi_s32 argc,const hi_char * argv[])997 hi_u32 cmd_softap_show_sta(hi_s32 argc, const hi_char *argv[])
998 {
999 hi_s32 ret;
1000 hi_u32 sta_index;
1001 hi_u32 sta_num = WIFI_DEFAULT_MAX_NUM_STA;
1002 hi_wifi_ap_sta_info sta_list[WIFI_DEFAULT_MAX_NUM_STA];
1003 hi_wifi_ap_sta_info *sta_list_node = HI_NULL;
1004
1005 hi_unref_param(argc);
1006 hi_unref_param(argv);
1007
1008 ret = hi_wifi_softap_get_connected_sta(sta_list, &sta_num);
1009 if (ret != HISI_OK) {
1010 return HI_ERR_FAILURE;
1011 }
1012
1013 sta_list_node = sta_list;
1014 for (sta_index = 0; sta_index < sta_num; sta_index++, sta_list_node++) {
1015 hi_at_printf("+SHOWSTA:" AT_MACSTR, at_mac2str(sta_list_node->mac));
1016 hi_at_printf("\r\n");
1017 }
1018
1019 hi_at_printf("OK\r\n");
1020 return HI_ERR_SUCCESS;
1021 }
1022
1023 /*****************************************************************************
1024 * Func description: start softap
1025 * example: AT+STARTAP="hisilicon",0,6,1,"123456789"
1026 AT+STARTAP="hisilicon",0,6,0
1027 *****************************************************************************/
cmd_start_softap(hi_s32 argc,const hi_char * argv[])1028 hi_u32 cmd_start_softap(hi_s32 argc, const hi_char *argv[])
1029 {
1030 hi_wifi_softap_config hapd_conf = {0};
1031 hi_char ifname[WIFI_IFNAME_MAX_SIZE + 1] = {0};
1032 hi_s32 ifname_len = sizeof(ifname);
1033 hi_s32 len;
1034
1035 if (((argc != 4) && (argc != 5)) || (at_param_null_check(argc, argv) == HI_ERR_FAILURE)) { /* argc 4/5 */
1036 return HI_ERR_FAILURE;
1037 }
1038
1039 /* get ssid */
1040 if ((argv[0][0] != '\"') || (*(argv[0] + strlen(argv[0]) - 1) != '\"') ||
1041 (memcpy_s(hapd_conf.ssid, HI_WIFI_MAX_SSID_LEN + 1, argv[0] + 1, strlen(argv[0]) - 2) != EOK)) { /* 2 */
1042 return HI_ERR_FAILURE;
1043 }
1044
1045 /* get ssid_hidden,Scope 0~1 */
1046 if ((integer_check(argv[1]) != HI_ERR_SUCCESS) || (atoi(argv[1]) < 0) || (atoi(argv[1]) > 1)) {
1047 return HI_ERR_FAILURE;
1048 }
1049 hapd_conf.ssid_hidden = atoi(argv[1]);
1050
1051 /* get channel,Scope1~14 */
1052 if ((integer_check(argv[2]) != HI_ERR_SUCCESS) || (atoi(argv[2]) <= 0) || (atoi(argv[2]) > 14)) { /* argc 2 */
1053 return HI_ERR_FAILURE;
1054 }
1055 hapd_conf.channel_num = (hi_uchar)atoi(argv[2]); /* 2 */
1056
1057 if ((integer_check(argv[3]) == HI_ERR_FAILURE) || /* 3 */
1058 ((atoi(argv[3]) != HI_WIFI_SECURITY_OPEN) && (atoi(argv[3]) != HI_WIFI_SECURITY_WPA2PSK) && /* 3 */
1059 (atoi(argv[3]) != HI_WIFI_SECURITY_WPAPSK_WPA2PSK_MIX)) || /* 3 */
1060 ((atoi(argv[3]) == HI_WIFI_SECURITY_OPEN) && (argc != 4))) { /* argc 3/4 */
1061 return HI_ERR_FAILURE;
1062 }
1063 hapd_conf.authmode = (hi_wifi_auth_mode)atoi(argv[3]); /* 3 */
1064
1065 /* get authmode */
1066 if ((hapd_conf.authmode != HI_WIFI_SECURITY_OPEN)) {
1067 if ((argc != 5) || (strlen(argv[4]) > HI_WIFI_AP_KEY_LEN_MAX + 2) || /* argc 4/5, len plus 2 */
1068 (strlen(argv[4]) < HI_WIFI_AP_KEY_LEN_MIN + 2)) { /* argc 4, len plus 2 */
1069 return HI_ERR_FAILURE;
1070 }
1071 const hi_char *buf = argv[4]; /* argc 4 */
1072 len = (int)strlen(argv[4]); /* argc 4 */
1073 if ((*buf != '\"') || (*(buf + len - 1) != '\"') ||
1074 (memcpy_s((hi_char*)hapd_conf.key, HI_WIFI_AP_KEY_LEN + 1, buf + 1, len - 2) != EOK)) { /* len minus 2 */
1075 return HI_ERR_FAILURE;
1076 }
1077 }
1078 if (hi_wifi_softap_start(&hapd_conf, ifname, &ifname_len) != HISI_OK) {
1079 return HI_ERR_FAILURE;
1080 }
1081
1082 if (hi_wifi_set_bandwidth(DEFAULT_IFNAME_AP, strlen(DEFAULT_IFNAME_AP) + 1, g_bw_setup_value) != HI_ERR_SUCCESS) {
1083 hi_wifi_softap_stop();
1084 return HI_ERR_FAILURE;
1085 }
1086
1087 hi_at_printf("OK\r\n");
1088 return HI_ERR_SUCCESS;
1089 }
1090
1091 /*****************************************************************************
1092 * Func description: start softap
1093 * example: AT+SETAPADV=2,10,100,2,3600,0
1094 *****************************************************************************/
cmd_set_softap_advance(hi_s32 argc,const hi_char * argv[])1095 hi_u32 cmd_set_softap_advance(hi_s32 argc, const hi_char *argv[])
1096 {
1097 hi_s32 ret, value, i;
1098
1099 if (argc != 6) { /* The command has six fixed parameters.CNcomment:"+SETAPADV"命令固定6个命令参数 */
1100 return HI_ERR_FAILURE;
1101 }
1102 for (i = 0; i < argc; i++) {
1103 if ((argv[i] != HI_NULL) && (integer_check(argv[i]) != HI_ERR_SUCCESS)) {
1104 return HI_ERR_FAILURE;
1105 }
1106
1107 if (i == 0) {
1108 value = (argv[i] != HI_NULL) ? atoi(argv[i]) : HI_WIFI_PHY_MODE_11BGN;
1109 if ((value == HI_WIFI_PHY_MODE_11B) && (argv[1] != HI_NULL) && (strcmp(argv[1], "20"))) { /* 20:bw */
1110 return HI_ERR_FAILURE;
1111 }
1112 ret = hi_wifi_softap_set_protocol_mode((hi_wifi_protocol_mode)value);
1113 } else if (i == 1) {
1114 if ((argv[i] == HI_NULL) || !(strcmp(argv[i], "20"))) { /* 20M */
1115 g_bw_setup_value = HI_WIFI_BW_LEGACY_20M;
1116 } else if (!(strcmp(argv[i], "10"))) { /* 10M */
1117 g_bw_setup_value = HI_WIFI_BW_HIEX_10M;
1118 } else if (!(strcmp(argv[i], "5"))) { /* 5M */
1119 g_bw_setup_value = HI_WIFI_BW_HIEX_5M;
1120 } else {
1121 return HI_ERR_FAILURE;
1122 }
1123 ret = HISI_OK;
1124 } else if (i == 2) { /* i is 2 */
1125 ret = (argv[i] != HI_NULL) ? hi_wifi_softap_set_beacon_period(atoi(argv[i])) : HISI_OK;
1126 } else if (i == 3) { /* i is 3 */
1127 ret = (argv[i] != HI_NULL) ? hi_wifi_softap_set_dtim_period(atoi(argv[i])) : HISI_OK;
1128 } else if (i == 4) { /* i is 4 */
1129 ret = (argv[i] != HI_NULL) ? hi_wifi_softap_set_group_rekey(atoi(argv[i])) : HISI_OK;
1130 } else if (i == 5) { /* i is 5 */
1131 ret = (argv[i] != HI_NULL) ? hi_wifi_softap_set_shortgi(atoi(argv[i])) : HISI_OK;
1132 } else {
1133 return HI_ERR_FAILURE;
1134 }
1135 if (ret != HISI_OK) {
1136 return HI_ERR_FAILURE;
1137 }
1138 }
1139
1140 hi_at_printf("OK\r\n");
1141 return HI_ERR_SUCCESS;
1142 }
1143
1144 /*****************************************************************************
1145 * Func description: stop softap
1146 *****************************************************************************/
cmd_stop_softap(hi_s32 argc,const hi_char * argv[])1147 hi_u32 cmd_stop_softap(hi_s32 argc, const hi_char *argv[])
1148 {
1149 hi_unref_param(argc);
1150 hi_unref_param(argv);
1151
1152 if (hi_wifi_softap_stop() != HISI_OK) {
1153 return HI_ERR_FAILURE;
1154 }
1155
1156 hi_at_printf("OK\r\n");
1157 return HI_ERR_SUCCESS;
1158 }
1159
1160 /*****************************************************************************
1161 * Func description: softap disconnect station
1162 * example: AT+DEAUTHSTA=90:2B:D2:E4:CE:28
1163 *****************************************************************************/
cmd_softap_deauth_sta(hi_s32 argc,const hi_char * argv[])1164 hi_u32 cmd_softap_deauth_sta(hi_s32 argc, const hi_char *argv[])
1165 {
1166 hi_uchar mac_addr[HI_WIFI_MAC_LEN + 1] = {0};
1167 hi_s32 ret;
1168
1169 if ((argc != 1) || (argv[0] == HI_NULL) || (strlen(argv[0]) != HI_WIFI_TXT_ADDR_LEN)) {
1170 return HI_ERR_FAILURE;
1171 }
1172
1173 if (cmd_strtoaddr(argv[0], mac_addr, HI_WIFI_MAC_LEN) != HISI_OK) {
1174 return HI_ERR_FAILURE;
1175 }
1176
1177 ret = hi_wifi_softap_deauth_sta(mac_addr, HI_WIFI_MAC_LEN);
1178 if (ret != HISI_OK) {
1179 return HI_ERR_FAILURE;
1180 }
1181
1182 hi_at_printf("OK\r\n");
1183 return HI_ERR_SUCCESS;
1184 }
1185
at_ap_scan(hi_void)1186 hi_u32 at_ap_scan(hi_void)
1187 {
1188 hi_at_printf("ERROR:TBD\r\n");
1189 return HI_ERR_SUCCESS;
1190 }
1191
1192 const at_cmd_func g_at_ap_func_tbl[] = {
1193 {"+STARTAP", 8, HI_NULL, HI_NULL, (at_call_back_func)cmd_start_softap, HI_NULL},
1194 {"+SETAPADV", 9, HI_NULL, HI_NULL, (at_call_back_func)cmd_set_softap_advance, HI_NULL},
1195 {"+STOPAP", 7, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_stop_softap},
1196 {"+SHOWSTA", 8, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_softap_show_sta},
1197 {"+DEAUTHSTA", 10, HI_NULL, HI_NULL, (at_call_back_func)cmd_softap_deauth_sta, HI_NULL},
1198 {"+APSCAN", 7, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)at_ap_scan},
1199 };
1200
1201 #define AT_AP_FUNC_NUM (sizeof(g_at_ap_func_tbl) / sizeof(g_at_ap_func_tbl[0]))
1202
hi_at_softap_cmd_register(void)1203 hi_void hi_at_softap_cmd_register(void)
1204 {
1205 hi_at_register_cmd(g_at_ap_func_tbl, AT_AP_FUNC_NUM);
1206 }
1207
1208 #ifdef LOSCFG_APP_MESH
cmd_mesh_auto_get_ssid(const hi_char * argv[],hi_mesh_autolink_config * mesh_auto_config)1209 hi_u32 cmd_mesh_auto_get_ssid(const hi_char *argv[], hi_mesh_autolink_config *mesh_auto_config)
1210 {
1211 size_t ssid_len = 0;
1212 errno_t rc;
1213
1214 /* get ssid */
1215 if (argv[1][0] == 'P') {
1216 if (strlen(argv[1]) > HI_WIFI_MAX_SSID_LEN * 4 + 3) { /* ssid length should less than 32*4+3 */
1217 return HI_ERR_FAILURE;
1218 }
1219 } else if (strlen(argv[1]) > HI_WIFI_MAX_SSID_LEN + 2) { /* ssid length should less than 32+2 */
1220 return HI_ERR_FAILURE;
1221 }
1222
1223 /* ssid hex to string */
1224 hi_char *tmp = at_parse_string(argv[1], &ssid_len);
1225 if (tmp == HI_NULL) {
1226 return HI_ERR_FAILURE;
1227 }
1228 if ((ssid_len > HI_WIFI_MAX_SSID_LEN) || (ssid_len == 0)) {
1229 at_free(tmp);
1230 return HI_ERR_FAILURE;
1231 }
1232
1233 rc = memcpy_s(mesh_auto_config->ssid, HI_WIFI_MAX_SSID_LEN + 1, tmp, strlen(tmp) + 1);
1234 at_free(tmp);
1235 if (rc != EOK) {
1236 return HI_ERR_FAILURE;
1237 }
1238
1239 return HI_ERR_SUCCESS;
1240 }
1241
1242 /*****************************************************************************
1243 * Func description: start mesh auto join
1244 * example: AT+MAUTOJOIN=1,"router_mesh",0
1245 AT+MAUTOJOIN=1,"router_mesh",1,"123456789"
1246 *****************************************************************************/
cmd_mesh_auto_connect(hi_s32 argc,const hi_char * argv[])1247 hi_s32 cmd_mesh_auto_connect(hi_s32 argc, const hi_char* argv[])
1248 {
1249 hi_mesh_autolink_config mesh_auto_config = {0};
1250
1251 if ((argc < 3) || (argc > 4)) { /* argc 3/4 */
1252 return HI_ERR_FAILURE;
1253 }
1254
1255 /* get usr config mesh type */
1256 if ((integer_check(argv[0]) != HI_ERR_SUCCESS) || (atoi(argv[0]) < HI_MESH_USRCONFIG_MBR) ||
1257 (atoi(argv[0]) > HI_MESH_USRCONFIG_AUTO)) {
1258 return HI_ERR_FAILURE;
1259 }
1260 mesh_auto_config.usr_cfg_role = (hi_mesh_autolink_usrcfg_node_type)atoi(argv[0]);
1261
1262 /* get ssid */
1263 if (cmd_mesh_auto_get_ssid(argv, &mesh_auto_config) != HI_ERR_SUCCESS) {
1264 return HI_ERR_FAILURE;
1265 }
1266
1267 /* get auth_type */
1268 if ((integer_check(argv[2]) == HI_ERR_FAILURE) || /* argc 2 */
1269 ((atoi(argv[2]) != HI_MESH_OPEN) && (atoi(argv[2]) != HI_MESH_AUTH)) || /* argc 2 */
1270 ((atoi(argv[2]) == HI_MESH_OPEN) && (argc != 3))) { /* argc 2/3 */
1271 return HI_ERR_FAILURE;
1272 }
1273 mesh_auto_config.auth = (hi_mesh_autolink_auth_type)atoi(argv[2]); /* 2 */
1274
1275 /* get key */
1276 if (mesh_auto_config.auth == HI_MESH_AUTH) {
1277 if ((argc != 4) || (strlen(argv[3]) > HI_WIFI_MS_KEY_LEN_MAX + 2) || /* 4,3,2 */
1278 (strlen(argv[3]) < HI_WIFI_MS_KEY_LEN_MIN + 2)) { /* 3,2 */
1279 return HI_ERR_FAILURE;
1280 }
1281 const hi_char *buf = argv[3]; /* 3 */
1282 size_t len = strlen(argv[3]); /* 3 */
1283 if ((*buf != '\"') || (*(buf + len - 1) != '\"') ||
1284 (memcpy_s((hi_char*)mesh_auto_config.key, HI_WIFI_MESH_KEY_LEN_MAX + 1, buf + 1, len - 2) != EOK)) { /* 2 */
1285 return HI_ERR_FAILURE;
1286 }
1287 }
1288
1289 if (hi_mesh_start_autolink(&mesh_auto_config) != HISI_OK) {
1290 return HI_ERR_FAILURE;
1291 }
1292
1293 hi_at_printf("OK\r\n");
1294 return HI_ERR_SUCCESS;
1295 }
1296
1297 /*****************************************************************************
1298 * Func description: exit mesh network
1299 * example: AT+MEXIT
1300 * AT+MEXIT
1301 *****************************************************************************/
cmd_mesh_exit_network(hi_s32 argc,const hi_char * argv[])1302 hi_s32 cmd_mesh_exit_network(hi_s32 argc, const hi_char* argv[])
1303 {
1304 hi_s32 ret;
1305
1306 hi_unref_param(argv);
1307 hi_unref_param(argc);
1308
1309 ret = hi_mesh_exit_autolink();
1310 if (ret != HISI_OK) {
1311 return HI_ERR_FAILURE;
1312 }
1313
1314 hi_at_printf("OK\r\n");
1315 return HI_ERR_SUCCESS;
1316 }
1317
1318 /*****************************************************************************
1319 * Func description: set mesh router rssi threshold
1320 * example: AT+MSETRSSI=-50
1321 *****************************************************************************/
cmd_mesh_set_rssi_threshold(hi_s32 argc,const hi_char * argv[])1322 hi_s32 cmd_mesh_set_rssi_threshold(hi_s32 argc, const hi_char* argv[])
1323 {
1324 hi_s32 ret;
1325 hi_s32 usr_rssi_config;
1326
1327 if ((argc != 1) || (argv[0] == HI_NULL)) {
1328 return HI_ERR_FAILURE;
1329 }
1330
1331 usr_rssi_config = atoi(argv[0]);
1332 if ((usr_rssi_config < -127) || (usr_rssi_config > 10)) { /* range -127,10 */
1333 return HI_ERR_FAILURE;
1334 }
1335 ret = hi_mesh_autolink_set_router_rssi_threshold(usr_rssi_config);
1336 if (ret != HISI_OK) {
1337 return HI_ERR_FAILURE;
1338 }
1339
1340 hi_at_printf("OK\r\n");
1341 return HI_ERR_SUCCESS;
1342 }
1343
1344 /*****************************************************************************
1345 * Func description: set mesh autonetwork bw value
1346 * example: AT+MSETBW=5
1347 *****************************************************************************/
cmd_mesh_set_autonetwork_bw(hi_s32 argc,const hi_char * argv[])1348 hi_s32 cmd_mesh_set_autonetwork_bw(hi_s32 argc, const hi_char* argv[])
1349 {
1350 hi_wifi_bw bw_value;
1351 if (argc != 1) { /* "+MSETBW"命令固定1个命令参数 */
1352 return HI_ERR_FAILURE;
1353 }
1354
1355 if ((argv[0] != HI_NULL) && (integer_check(argv[0]) != HI_ERR_SUCCESS)) {
1356 return HI_ERR_FAILURE;
1357 }
1358
1359 if ((argv[0] != HI_NULL) && (atoi(argv[0]) == 5)) { /* bw 5 */
1360 bw_value = HI_WIFI_BW_HIEX_5M;
1361 } else if ((argv[0] != HI_NULL) && (atoi(argv[0]) == 10)) { /* bw 10 */
1362 bw_value = HI_WIFI_BW_HIEX_10M;
1363 } else {
1364 bw_value = HI_WIFI_BW_LEGACY_20M;
1365 }
1366
1367 hi_mesh_autolink_set_bw(bw_value);
1368 hi_at_printf("OK\r\n");
1369 return HI_ERR_SUCCESS;
1370 }
1371
1372 const at_cmd_func g_at_mesh_func_tbl[] = {
1373 {"+MAUTOJOIN", 10, HI_NULL, HI_NULL, (at_call_back_func)cmd_mesh_auto_connect, HI_NULL},
1374 {"+MEXIT", 6, HI_NULL, HI_NULL, HI_NULL, (at_call_back_func)cmd_mesh_exit_network},
1375 {"+MSETRSSI", 9, HI_NULL, HI_NULL, (at_call_back_func)cmd_mesh_set_rssi_threshold, HI_NULL},
1376 {"+MSETBW", 7, HI_NULL, HI_NULL, (at_call_back_func)cmd_mesh_set_autonetwork_bw, HI_NULL},
1377 };
1378
1379 #define AT_MESH_FUNC_NUM (sizeof(g_at_mesh_func_tbl) / sizeof(g_at_mesh_func_tbl[0]))
1380
hi_at_mesh_cmd_register(void)1381 hi_void hi_at_mesh_cmd_register(void)
1382 {
1383 hi_at_register_cmd(g_at_mesh_func_tbl, AT_MESH_FUNC_NUM);
1384 }
1385 #endif
1386 #ifdef __cplusplus
1387 #if __cplusplus
1388 }
1389 #endif
1390 #endif
1391