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 * Description: 网络适配实现 （此文件为DEMO，需集成方适配修改）
15 */
16 #include "hilink_network_adapter.h"
17
18 #include <stdbool.h>
19 #include <stddef.h>
20 #include "wifi_device.h"
21 #include "wifi_event.h"
22 #include "wifi_device_config.h"
23 #include "hilink_sal_defines.h"
24 #include "hilink_socket_adapter.h"
25 #include "hilink_str_adapter.h"
26 #include "securec.h"
27 #include "hilink_thread_adapter.h"
28 #include "hilink_mem_adapter.h"
29 #include "soc_wifi_api.h"
30 #include "lwip/netifapi.h"
31 #include "nv.h"
32 #include "nv_common_cfg.h"
33 #include "efuse_porting.h"
34
35 #define MAX_IP_LEN 40
36 #define MAX_SCAN_TIMES 4
37 #define DEF_SCAN_TIMEOUT 15
38 #define MS_PER_SECOND 1000
39 #define WIFI_SCANNING 1
40
41 static bool g_isRegisterWifiEvent = false;
42 static bool g_isStaScanSuccess = false;
43 static wifi_event_stru g_eventHandler;
44 static unsigned short g_disconnectReason = 0;
45 static bool g_isReasonRefresh = false;
46 static int g_offline_mode_scan_flag = 0;
47
get_wifi_recovery_type(void)48 unsigned int get_wifi_recovery_type(void)
49 {
50 return (0x01 | 0x02); /* 0x01|0x02 : 连线网络优化功能开启 */
51 }
52
sta_setup_dhcp(void)53 static int sta_setup_dhcp(void)
54 {
55 int ret = 0;
56 struct netif *netif_p = netifapi_netif_find("wlan0");
57 if (netif_p == NULL) {
58 return HILINK_SAL_NOK;
59 }
60 ret = netifapi_dhcp_start(netif_p);
61 if (ret == 0) {
62 return HILINK_SAL_OK;
63 }
64
65 return HILINK_SAL_NOK;
66 }
AddDeviceConfig(wifi_sta_config_stru * config)67 static int AddDeviceConfig(wifi_sta_config_stru *config)
68 {
69 if (config == NULL) {
70 HILINK_SAL_WARN("invalid param\r\n");
71 return HILINK_SAL_PARAM_INVALID;
72 }
73
74 hilink_connect_info_t connect_info;
75 (void)memset_s(&connect_info, sizeof(connect_info), 0, sizeof(connect_info));
76
77 if (memcpy_s(connect_info.ssid, sizeof(connect_info.ssid), config->ssid, strlen((char *)config->ssid)) != EOK) {
78 HILINK_SAL_ERROR("memcpy_s error\r\n");
79 return HILINK_SAL_NOK;
80 }
81
82 if (memcpy_s(connect_info.pwd, sizeof(connect_info.pwd), config->pre_shared_key,
83 strlen((char *)config->pre_shared_key)) != EOK) {
84 HILINK_SAL_ERROR("memcpy_s error\r\n");
85 return HILINK_SAL_NOK;
86 }
87
88 if (memcpy_s(connect_info.bssid, sizeof(connect_info.bssid), config->bssid,
89 sizeof(config->bssid)) != EOK) {
90 HILINK_SAL_ERROR("memcpy_s error\r\n");
91 return HILINK_SAL_NOK;
92 }
93
94 uint32_t nv_ret = ERRCODE_FAIL;
95 nv_ret = uapi_nv_write(NV_ID_HILINK_CONNECT_INFO, (uint8_t *)&connect_info, sizeof(connect_info));
96 if (nv_ret != ERRCODE_SUCC) {
97 HILINK_SAL_ERROR("read write connect info to nv failed\r\n");
98 return HILINK_SAL_NOK;
99 }
100 return HILINK_SAL_OK;
101 }
102
GetDeviceConfigs(wifi_sta_config_stru * config)103 static int GetDeviceConfigs(wifi_sta_config_stru *config)
104 {
105 if (config == NULL) {
106 HILINK_SAL_WARN("invalid param\r\n");
107 return HILINK_SAL_PARAM_INVALID;
108 }
109
110 hilink_connect_info_t connect_info;
111 (void)memset_s(&connect_info, sizeof(connect_info), 0, sizeof(connect_info));
112
113 uint16_t connect_info_len = 0;
114 uint32_t nv_ret = ERRCODE_FAIL;
115 nv_ret = uapi_nv_read(NV_ID_HILINK_CONNECT_INFO, sizeof(hilink_connect_info_t), &connect_info_len,
116 (uint8_t *)&connect_info);
117 if (nv_ret != ERRCODE_SUCC) {
118 HILINK_SAL_ERROR("read hilink connect info from nv failed\r\n");
119 return HILINK_SAL_NOK;
120 }
121
122 if (memcpy_s(config->ssid, sizeof(config->ssid), connect_info.ssid, sizeof(connect_info.ssid)) != EOK) {
123 HILINK_SAL_ERROR("memcpy_s error\r\n");
124 return HILINK_SAL_NOK;
125 }
126
127 if (memcpy_s(config->pre_shared_key, sizeof(config->pre_shared_key), connect_info.pwd, sizeof(connect_info.pwd)) !=
128 EOK) {
129 HILINK_SAL_ERROR("memcpy_s error\r\n");
130 return HILINK_SAL_NOK;
131 }
132
133 if (memcpy_s(config->bssid, sizeof(config->bssid), connect_info.bssid, sizeof(connect_info.bssid)) !=
134 EOK) {
135 HILINK_SAL_ERROR("memcpy_s error\r\n");
136 return HILINK_SAL_NOK;
137 }
138
139 return HILINK_SAL_OK;
140 }
RemoveDevice(void)141 static int RemoveDevice(void)
142 {
143 hilink_connect_info_t connect_info;
144 (void)memset_s(&connect_info, sizeof(connect_info), 0, sizeof(connect_info));
145
146 uint32_t nv_ret = ERRCODE_FAIL;
147 nv_ret = uapi_nv_write(NV_ID_HILINK_CONNECT_INFO, (uint8_t *)&connect_info, sizeof(connect_info));
148 if (nv_ret != ERRCODE_SUCC) {
149 HILINK_SAL_ERROR("remove connect info to nv failed.\r\n");
150 }
151
152 return HILINK_SAL_OK;
153 }
get_softap_local_ip(char * localIp,unsigned char len)154 static int get_softap_local_ip(char *localIp, unsigned char len)
155 {
156 struct netif *lwip_netif = netifapi_netif_find("ap0");
157 if (lwip_netif == NULL) {
158 lwip_netif = netifapi_netif_find("wlan0");
159 if (lwip_netif == NULL) {
160 return HILINK_SAL_GET_IP_ERR;
161 }
162 }
163
164 if (memcpy_s(localIp, len, ip4addr_ntoa(&(lwip_netif->ip_addr.u_addr.ip4)),
165 strlen(ip4addr_ntoa(&(lwip_netif->ip_addr.u_addr.ip4)))) != EOK) {
166 return HILINK_SAL_GET_IP_ERR;
167 }
168
169 return HILINK_SAL_OK;
170 }
HILINK_GetLocalIp(char * localIp,unsigned char len)171 int HILINK_GetLocalIp(char *localIp, unsigned char len)
172 {
173 if ((localIp == NULL) || (len == 0)) {
174 HILINK_SAL_WARN("invalid param\r\n");
175 return HILINK_SAL_PARAM_INVALID;
176 }
177 /* 避免循环调用导致的打印刷屏 */
178 static bool isPrint = false;
179 if (get_softap_local_ip(localIp, len) != HILINK_SAL_OK) {
180 if (!isPrint) {
181 HILINK_SAL_NOTICE("HILINK_GetLocalIp fail.\r\n");
182 isPrint = true;
183 }
184 return HILINK_SAL_GET_IP_ERR;
185 }
186 isPrint = false;
187
188 return HILINK_SAL_OK;
189 }
190
HILINK_GetMacAddr(unsigned char * mac,unsigned char len)191 int HILINK_GetMacAddr(unsigned char *mac, unsigned char len)
192 {
193 if ((mac == NULL) || (len < WIFI_MAC_LEN)) {
194 HILINK_SAL_WARN("invalid param\r\n");
195 return HILINK_SAL_PARAM_INVALID;
196 }
197
198 /* 从efuse获取mac地址 */
199 unsigned char efuse_left_count = 0;
200 if (efuse_read_mac(mac, WIFI_MAC_LEN, &efuse_left_count) != ERRCODE_SUCC) {
201 HILINK_SAL_ERROR("get device macaddr from efuse fail\r\n");
202 return HILINK_SAL_GET_MAC_ERR;
203 }
204
205 return HILINK_SAL_OK;
206 }
207
GetWifiConfigFromOhos(wifi_sta_config_stru * config)208 static int GetWifiConfigFromOhos(wifi_sta_config_stru *config)
209 {
210 if (config == NULL) {
211 HILINK_SAL_WARN("invalid param\r\n");
212 return HILINK_SAL_PARAM_INVALID;
213 }
214
215 wifi_sta_config_stru wifiConfig;
216 (void)memset_s(&wifiConfig, sizeof(wifiConfig), 0, sizeof(wifiConfig));
217
218 static bool isPrint = false;
219 if (GetDeviceConfigs(&wifiConfig) != HILINK_SAL_OK) {
220 if (!isPrint) {
221 HILINK_SAL_ERROR("get device config fail\r\n");
222 isPrint = true;
223 }
224 return HILINK_SAL_GET_WIFI_INFO_ERR;
225 }
226 isPrint = false;
227
228 if (memcpy_s(config, sizeof(wifi_sta_config_stru), &wifiConfig, sizeof(wifi_sta_config_stru)) != EOK) {
229 HILINK_SAL_ERROR("memcpy error\r\n");
230 return HILINK_SAL_MEMCPY_ERR;
231 }
232 return HILINK_SAL_OK;
233 }
234
HILINK_GetWiFiSsid(char * ssid,unsigned int * ssidLen)235 int HILINK_GetWiFiSsid(char *ssid, unsigned int *ssidLen)
236 {
237 if ((ssid == NULL) || (ssidLen == NULL) || (*ssidLen == 0)) {
238 HILINK_SAL_WARN("invalid param\r\n");
239 return HILINK_SAL_PARAM_INVALID;
240 }
241
242 wifi_sta_config_stru result;
243 (void)memset_s(&result, sizeof(result), 0, sizeof(result));
244 /* 避免循环调用导致的打印刷屏 */
245 static bool isPrint = false;
246
247 int ret = GetWifiConfigFromOhos(&result);
248 if ((ret != HILINK_SAL_OK) || (result.ssid[0] == '\0') || (HILINK_Strlen((char *)result.ssid) >=
249 sizeof(result.ssid))) {
250 if (!isPrint) {
251 HILINK_SAL_NOTICE("get wifi ssid fail\r\n");
252 isPrint = true;
253 }
254 /* 初次配网获取不到ssid */
255 return HILINK_SAL_OK;
256 }
257 isPrint = false;
258 if (strcpy_s(ssid, WIFI_MAX_SSID_LEN, (char *)result.ssid) != EOK) {
259 HILINK_SAL_ERROR("strcpy error\r\n");
260 return HILINK_SAL_STRCPY_ERR;
261 }
262 *ssidLen = HILINK_Strlen(ssid);
263
264 return HILINK_SAL_OK;
265 }
266
HILINK_SetWiFiInfo(const char * ssid,unsigned int ssidLen,const char * pwd,unsigned int pwdLen)267 int HILINK_SetWiFiInfo(const char *ssid, unsigned int ssidLen, const char *pwd, unsigned int pwdLen)
268 {
269 wifi_sta_config_stru config;
270 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
271
272 /* 删除旧wifi配置 */
273 if (RemoveDevice() != HILINK_SAL_OK) {
274 HILINK_SAL_ERROR("remove config error\r\n");
275 return HILINK_SAL_REMOVE_WIFI_ERR;
276 }
277
278 if ((ssidLen != 0) && (ssid != NULL)) {
279 if (memcpy_s(config.ssid, sizeof(config.ssid), ssid, ssidLen) != EOK) {
280 HILINK_SAL_ERROR("memcpy error\r\n");
281 return HILINK_SAL_MEMCPY_ERR;
282 }
283 } else {
284 HILINK_SAL_NOTICE("clear wifi info\r\n");
285 return HILINK_SAL_OK;
286 }
287
288 if ((pwdLen != 0) && (pwd != NULL)) {
289 if (memcpy_s(config.pre_shared_key, sizeof(config.pre_shared_key), pwd, pwdLen) != EOK) {
290 HILINK_SAL_ERROR("memcpy error\r\n");
291 return HILINK_SAL_MEMCPY_ERR;
292 }
293 config.security_type = WIFI_SEC_TYPE_WPA2_WPA_PSK_MIX;
294 } else {
295 config.security_type = WIFI_SEC_TYPE_OPEN;
296 }
297
298 int ret = AddDeviceConfig(&config);
299 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
300 if (ret != HILINK_SAL_OK) {
301 HILINK_SAL_ERROR("add device config error %d\r\n", ret);
302 return HILINK_SAL_SET_WIFI_ERR;
303 }
304
305 return HILINK_SAL_OK;
306 }
307
HILINK_ReconnectWiFi(void)308 void HILINK_ReconnectWiFi(void)
309 {
310 if (wifi_sta_disconnect() != ERRCODE_SUCC) {
311 HILINK_SAL_ERROR("disconnect wifi error\r\n");
312 return;
313 }
314 if (HILINK_ConnectWiFi() != HILINK_SAL_OK) {
315 HILINK_SAL_ERROR("connect wifi fail\r\n");
316 return;
317 }
318 }
319
OnWifiScanStateChangedCallback(int state,int size)320 static void OnWifiScanStateChangedCallback(int state, int size)
321 {
322 (void)size;
323 if (state == WIFI_STATE_AVALIABLE) {
324 g_isStaScanSuccess = true;
325 }
326 }
327
OnWifiConnectionChangedCallback(int state,const wifi_linked_info_stru * info,int reason_code)328 static void OnWifiConnectionChangedCallback(int state, const wifi_linked_info_stru *info, int reason_code)
329 {
330 (void)state;
331 (void)info;
332
333 /* 0x8002,0x800e,0x800f: 密码错误场景对端返回的错误码 */
334 if ((reason_code == 0x8002) || (reason_code == 0x800e) || (reason_code == 0x800f)) {
335 g_disconnectReason = 15; /* 15: 密码错误场景统一上报错误码 15 */
336 } else {
337 g_disconnectReason = reason_code;
338 }
339 HILINK_SAL_NOTICE("state: %d, disconnectedReason %u\r\n", state, g_disconnectReason);
340 g_isReasonRefresh = true;
341 }
342
OnHotspotStaJoinCallback(const wifi_sta_info_stru * info)343 static void OnHotspotStaJoinCallback(const wifi_sta_info_stru *info)
344 {
345 (void)info;
346 HILINK_SAL_NOTICE("OnHotspotStaJoinCallback...\r\n");
347 }
348
OnHotspotStaLeaveCallback(const wifi_sta_info_stru * info)349 static void OnHotspotStaLeaveCallback(const wifi_sta_info_stru *info)
350 {
351 (void)info;
352 HILINK_SAL_NOTICE("OnHotspotStaLeaveCallback...\r\n");
353 }
354
OnHotspotStateChangedCallback(int state)355 static void OnHotspotStateChangedCallback(int state)
356 {
357 (void)state;
358 HILINK_SAL_NOTICE("OnHotspotStateChangedCallback, state[%d]\r\n", state);
359 }
360
RegisterWifiEventToOhos(void)361 static int RegisterWifiEventToOhos(void)
362 {
363 if (g_isRegisterWifiEvent) {
364 HILINK_SAL_NOTICE("wifievent has been registered.\r\n");
365 return HILINK_SAL_OK;
366 }
367
368 g_eventHandler.wifi_event_scan_state_changed = OnWifiScanStateChangedCallback;
369 g_eventHandler.wifi_event_connection_changed = OnWifiConnectionChangedCallback;
370 g_eventHandler.wifi_event_softap_sta_join = OnHotspotStaJoinCallback;
371 g_eventHandler.wifi_event_softap_sta_leave = OnHotspotStaLeaveCallback;
372 g_eventHandler.wifi_event_softap_state_changed = OnHotspotStateChangedCallback;
373
374 if (wifi_register_event_cb(&g_eventHandler) != ERRCODE_SUCC) {
375 HILINK_SAL_ERROR("Register wifi event fail.\r\n");
376 return HILINK_SAL_SET_WIFI_ERR;
377 }
378 g_isRegisterWifiEvent = true;
379 return HILINK_SAL_OK;
380 }
381
AdvanceScanWifiByOhos(const wifi_sta_config_stru * config)382 static int AdvanceScanWifiByOhos(const wifi_sta_config_stru *config)
383 {
384 int scanTimeout = DEF_SCAN_TIMEOUT;
385 g_isStaScanSuccess = false;
386
387 wifi_scan_params_stru scanParams;
388 (void)memset_s(&scanParams, sizeof(scanParams), 0, sizeof(scanParams));
389
390 if (memcpy_s(scanParams.ssid, sizeof(scanParams.ssid), config->ssid,
391 HILINK_Strlen((char *)config->ssid)) != EOK) {
392 HILINK_SAL_ERROR("memcpy error\r\n");
393 return HILINK_SAL_MEMCPY_ERR;
394 }
395 scanParams.scan_type = WIFI_SSID_SCAN;
396 scanParams.ssid_len = (char)HILINK_Strlen((char *)config->ssid);
397
398 if (wifi_sta_scan_advance(&scanParams) != ERRCODE_SUCC) {
399 HILINK_SAL_ERROR("wifi advance scan fail\r\n");
400 return HILINK_SAL_SCAN_WIFI_ERR;
401 }
402
403 while (scanTimeout > 0) {
404 HILINK_MilliSleep(MS_PER_SECOND);
405 scanTimeout--;
406 if (g_isStaScanSuccess == true) {
407 break;
408 }
409 }
410 if (scanTimeout == 0) {
411 HILINK_SAL_ERROR("wifi advance scan timeout\r\n");
412 return HILINK_SAL_SCAN_WIFI_ERR;
413 }
414 return HILINK_SAL_OK;
415 }
416
GetScanWifiResultFromOhos(const wifi_sta_config_stru * config,wifi_scan_info_stru * info)417 static bool GetScanWifiResultFromOhos(const wifi_sta_config_stru *config, wifi_scan_info_stru *info)
418 {
419 bool ret = false;
420 unsigned int size = WIFI_SCAN_AP_LIMIT;
421 wifi_scan_info_stru *result = (wifi_scan_info_stru *)HILINK_Malloc(sizeof(wifi_scan_info_stru) * size);
422 if (result == NULL) {
423 HILINK_SAL_ERROR("malloc error\r\n");
424 return false;
425 }
426 (void)memset_s(result, sizeof(wifi_scan_info_stru) * size, 0, sizeof(wifi_scan_info_stru) * size);
427
428 if (wifi_sta_get_scan_info(result, &size) != ERRCODE_SUCC) {
429 HILINK_SAL_ERROR("Get wifi scan info fail.\r\n");
430 HILINK_Free(result);
431 return false;
432 }
433
434 if ((size == 0) || (size > WIFI_SCAN_AP_LIMIT)) {
435 HILINK_SAL_WARN("can not scan any wifi or scan size over limit, size:%u\r\n", size);
436 } else {
437 for (unsigned int i = 0; i < size; ++i) {
438 /* 匹配目标wifi：ssid完全匹配，且WiFi加密类型应同时open或者同时不为open */
439 if ((HILINK_Strcmp((char *)result[i].ssid, (char *)config->ssid) == 0) &&
440 ((config->security_type != WIFI_SEC_TYPE_OPEN && result[i].security_type != WIFI_SEC_TYPE_OPEN) ||
441 (config->security_type == WIFI_SEC_TYPE_OPEN && result[i].security_type == WIFI_SEC_TYPE_OPEN))) {
442 HILINK_SAL_NOTICE("find target ssid success\r\n");
443 if (memcpy_s(info, sizeof(wifi_scan_info_stru), &result[i], sizeof(wifi_scan_info_stru)) != 0) {
444 HILINK_SAL_ERROR("memcpy error\r\n");
445 break;
446 }
447 ret = true;
448 break;
449 }
450 }
451 }
452
453 HILINK_Free(result);
454 return ret;
455 }
456
SetSecurityTypeByScanInfo(wifi_sta_config_stru * config,const wifi_scan_info_stru * info)457 static void SetSecurityTypeByScanInfo(wifi_sta_config_stru *config, const wifi_scan_info_stru *info)
458 {
459 wifi_sta_config_stru tempConfig;
460 (void)memset_s(&tempConfig, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
461 if (memcpy_s(&tempConfig, sizeof(wifi_sta_config_stru), config, sizeof(wifi_sta_config_stru)) != EOK) {
462 HILINK_SAL_ERROR("memcpy_s error\r\n");
463 return;
464 }
465
466 if (memset_s(config->bssid, sizeof(config->bssid), 0, sizeof(config->bssid)) != EOK) {
467 HILINK_SAL_ERROR("memset_s error\r\n");
468 }
469
470 if (info->security_type == WIFI_SEC_TYPE_INVALID) {
471 /* 扫描出的加密方式非法时根据有无密码使用默认的PSK或OPEN加密方式 */
472 config->security_type = (config->pre_shared_key[0] == '\0') ? WIFI_SEC_TYPE_OPEN :
473 WIFI_SEC_TYPE_WPA2_WPA_PSK_MIX;
474 } else {
475 config->security_type = info->security_type;
476 }
477
478 if (config->security_type == WIFI_SEC_TYPE_WEP) {
479 unsigned char pwdLen = HILINK_Strlen((char *)config->pre_shared_key);
480 /* 设置密码，海思要求WEP的5和13位ASCII密码需要用双引号包起来，对应长度需要-2处理 */
481 if ((pwdLen == 5) || (pwdLen == 13)) {
482 char tmpSharedKey[WIFI_MAX_KEY_LEN] = {0};
483 tmpSharedKey[0] = '\"';
484 if (memcpy_s(tmpSharedKey + 1, sizeof(tmpSharedKey) - 2, config->pre_shared_key, pwdLen) != EOK) {
485 (void)memset_s(&tempConfig, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
486 return;
487 }
488 tmpSharedKey[pwdLen + 1] = '\"';
489 if (memcpy_s(config->pre_shared_key, sizeof(config->pre_shared_key), tmpSharedKey,
490 WIFI_MAX_KEY_LEN) != EOK) {
491 (void)memset_s(&tempConfig, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
492 (void)memset_s(tmpSharedKey, sizeof(tmpSharedKey), 0, sizeof(tmpSharedKey));
493 return;
494 }
495 (void)memset_s(tmpSharedKey, sizeof(tmpSharedKey), 0, sizeof(tmpSharedKey));
496 }
497 }
498
499 /* wifi配置与扫描后的结果对比，如果不同，需要刷新wifi配置 */
500 if (HILINK_Memcmp(config, &tempConfig, sizeof(wifi_sta_config_stru)) != 0) {
501 if (RemoveDevice() != HILINK_SAL_OK) {
502 HILINK_SAL_ERROR("remove config error\r\n");
503 (void)memset_s(&tempConfig, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
504 return;
505 }
506 if (AddDeviceConfig(config) != HILINK_SAL_OK) {
507 HILINK_SAL_ERROR("add config fail\r\n");
508 (void)memset_s(&tempConfig, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
509 return;
510 }
511 }
512
513 (void)memset_s(&tempConfig, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
514 return;
515 }
516
HILINK_RestartWiFi(void)517 int HILINK_RestartWiFi(void)
518 {
519 int ret;
520 if (wifi_is_sta_enabled() == 1) {
521 ret = wifi_sta_disable();
522 if (ret != ERRCODE_SUCC) {
523 HILINK_SAL_ERROR("disable wifi error, ret = %d\r\n", ret);
524 return HILINK_SAL_NOK;
525 }
526 }
527
528 ret = wifi_sta_enable();
529 if (ret != ERRCODE_SUCC) {
530 HILINK_SAL_ERROR("disable wifi error, ret = %d\r\n", ret);
531 return HILINK_SAL_NOK;
532 }
533
534 return HILINK_SAL_OK;
535 }
536
AddBssidToWifiConfig(int securityType,const unsigned char * bssid,unsigned int len)537 static int AddBssidToWifiConfig(int securityType, const unsigned char *bssid, unsigned int len)
538 {
539 /* 读取当前WiFi配置 */
540 wifi_sta_config_stru config;
541 (void)memset_s(&config, sizeof(config), 0, sizeof(config));
542 if ((GetWifiConfigFromOhos(&config) != HILINK_SAL_OK) || (config.ssid[0] == '\0')) {
543 HILINK_SAL_ERROR("get wifi config fail\r\n");
544 (void)memset_s(&config, sizeof(config), 0, sizeof(config));
545 return HILINK_SAL_GET_WIFI_INFO_ERR;
546 }
547
548 /* 拷贝bssid */
549 if (memcpy_s(config.bssid, sizeof(config.bssid), bssid, len) != EOK) {
550 HILINK_SAL_ERROR("memcpy bssid failed\r\n");
551 (void)memset_s(&config, sizeof(config), 0, sizeof(config));
552 return HILINK_SAL_MEMCPY_ERR;
553 }
554
555 /* harmonyos中，-1表示无效加密类型，仅更新有效加密类型 */
556 if (securityType != -1) {
557 config.security_type = securityType;
558 }
559
560 /* 更新WiFi配置 */
561 if (RemoveDevice() != HILINK_SAL_OK) {
562 HILINK_SAL_ERROR("remove config error\r\n");
563 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
564 return HILINK_SAL_REMOVE_WIFI_ERR;
565 }
566 if (AddDeviceConfig(&config) != HILINK_SAL_OK) {
567 HILINK_SAL_ERROR("add config fail\r\n");
568 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
569 return HILINK_SAL_ADD_WIFI_ERR;
570 }
571 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
572 return HILINK_SAL_OK;
573 }
574
RemoveBssidFromWifiConfig(void)575 static int RemoveBssidFromWifiConfig(void)
576 {
577 /* 读取当前WiFi配置 */
578 wifi_sta_config_stru config;
579 (void)memset_s(&config, sizeof(config), 0, sizeof(config));
580 if ((GetWifiConfigFromOhos(&config) != HILINK_SAL_OK) || (config.ssid[0] == '\0')) {
581 HILINK_SAL_ERROR("get wifi config fail\r\n");
582 (void)memset_s(&config, sizeof(config), 0, sizeof(config));
583 return HILINK_SAL_GET_WIFI_INFO_ERR;
584 }
585
586 /* 清除bssid */
587 if (memset_s(config.bssid, sizeof(config.bssid), 0, sizeof(config.bssid)) != EOK) {
588 HILINK_SAL_ERROR("memcpy bssid failed\r\n");
589 (void)memset_s(&config, sizeof(config), 0, sizeof(config));
590 return HILINK_SAL_MEMSET_ERR;
591 }
592
593 /* 更新WiFi配置 */
594 if (RemoveDevice() != HILINK_SAL_OK) {
595 HILINK_SAL_ERROR("remove config error\r\n");
596 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
597 return HILINK_SAL_REMOVE_WIFI_ERR;
598 }
599
600 if (AddDeviceConfig(&config) != HILINK_SAL_OK) {
601 HILINK_SAL_ERROR("add config fail\r\n");
602 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
603 return HILINK_SAL_ADD_WIFI_ERR;
604 }
605 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
606 return HILINK_SAL_OK;
607 }
608
HILINK_ConnectWiFiByBssid(int securityType,const unsigned char * bssid,unsigned int len)609 int HILINK_ConnectWiFiByBssid(int securityType, const unsigned char *bssid, unsigned int len)
610 {
611 if ((bssid == NULL) || (len == 0)) {
612 HILINK_SAL_ERROR("invalid param\r\n");
613 return HILINK_SAL_PARAM_INVALID;
614 }
615 /* 初始化WiFi */
616 if (wifi_is_sta_enabled() != 1) {
617 if (wifi_sta_enable() != ERRCODE_SUCC) {
618 HILINK_SAL_ERROR("enable wifi fail\r\n");
619 return HILINK_SAL_SET_WIFI_ERR;
620 }
621 }
622
623 if (RegisterWifiEventToOhos() != HILINK_SAL_OK) {
624 HILINK_SAL_ERROR("register wifi event fail\r\n");
625 return HILINK_SAL_SET_WIFI_ERR;
626 }
627
628 g_isReasonRefresh = false;
629
630 if (AddBssidToWifiConfig(securityType, bssid, len) != HILINK_SAL_OK) {
631 HILINK_SAL_ERROR("add bssid to config failed\r\n");
632 return HILINK_SAL_ADD_WIFI_ERR;
633 }
634
635 int netConnect = WIFI_DISCONNECTED;
636 if (HILINK_GetNetworkState(&netConnect) != HILINK_SAL_OK) {
637 /* 网络状态获取失败，不退出继续连接 */
638 HILINK_SAL_ERROR("get network state failed\r\n");
639 }
640 if (netConnect == WIFI_CONNECTED) {
641 /* 断开当前连接并重连 */
642 if (wifi_sta_disconnect() != ERRCODE_SUCC) {
643 HILINK_SAL_ERROR("disconnect wifi error\r\n");
644 return HILINK_SAL_CONENCT_WIFI_ERR;
645 }
646 }
647
648 wifi_sta_config_stru config;
649 memset_s(&config, sizeof(config), 0, sizeof(config));
650 if (GetWifiConfigFromOhos(&config) != HILINK_SAL_OK) {
651 return HILINK_SAL_GET_WIFI_INFO_ERR;
652 }
653
654 config.ip_type = DHCP;
655 if (wifi_sta_connect(&config) != ERRCODE_SUCC) {
656 HILINK_SAL_ERROR("connect to wifi fail.\n");
657 return HILINK_SAL_CONENCT_WIFI_ERR;
658 }
659
660 if (sta_setup_dhcp() != 0) {
661 HILINK_SAL_ERROR("set sta dhcp failed\r\n");
662 return HILINK_SAL_CONENCT_WIFI_ERR;
663 }
664
665 /* 指定完BSSID连接后及时清除BSSID配置，避免下次自动重连 */
666 if (RemoveBssidFromWifiConfig() != HILINK_SAL_OK) {
667 HILINK_SAL_ERROR("remove bssid to config failed\r\n");
668 return HILINK_SAL_ADD_WIFI_ERR;
669 }
670
671 return HILINK_SAL_OK;
672 }
673
HILINK_GetLastConnectResult(int * result)674 int HILINK_GetLastConnectResult(int *result)
675 {
676 if (result == NULL) {
677 HILINK_SAL_ERROR("invalid param\r\n");
678 return HILINK_SAL_PARAM_INVALID;
679 }
680
681 if (!g_isReasonRefresh) {
682 return HILINK_SAL_NOK;
683 }
684
685 *result = g_disconnectReason;
686 g_isReasonRefresh = false;
687 return HILINK_SAL_OK;
688 }
689
BuildScanParam(const HILINK_APScanParam * param,wifi_scan_params_stru * scanParams)690 static int BuildScanParam(const HILINK_APScanParam *param, wifi_scan_params_stru *scanParams)
691 {
692 HILINK_WifiScanType scanType = param->scanType;
693 HILINK_SAL_DEBUG("scan type: %d\r\n", scanType);
694
695 switch (scanType) {
696 case WIFI_SCAN_TPYE_SSID: {
697 unsigned int ssidLen = HILINK_Strlen((char *)param->ssid);
698 if ((param->ssid[0] == '\0') || (ssidLen != param->ssidLen)) {
699 HILINK_SAL_ERROR("invalid ssid param, len: %u, strlen: %u\r\n", param->ssidLen, ssidLen);
700 return HILINK_SAL_PARAM_INVALID;
701 }
702 if (memcpy_s(scanParams->ssid, sizeof(scanParams->ssid), param->ssid, param->ssidLen) != EOK) {
703 HILINK_SAL_ERROR("memcpy error\r\n");
704 return HILINK_SAL_MEMCPY_ERR;
705 }
706 scanParams->scan_type = WIFI_SSID_SCAN;
707 scanParams->ssid_len = param->ssidLen;
708 break;
709 }
710 case WIFI_SCAN_TPYE_BSSID: {
711 if (memcpy_s(scanParams->bssid, sizeof(scanParams->bssid), param->bssid, sizeof(param->ssid)) != EOK) {
712 HILINK_SAL_ERROR("memcpy error\r\n");
713 return HILINK_SAL_MEMCPY_ERR;
714 }
715 scanParams->scan_type = WIFI_BSSID_SCAN;
716 break;
717 }
718 case WIFI_SCAN_TPYE_FREQ: {
719 scanParams->scan_type = WIFI_CHANNEL_SCAN;
720 break;
721 }
722 default:
723 HILINK_SAL_ERROR("not support scan type, type: %d\r\n", scanType);
724 return HILINK_SAL_PARAM_INVALID;
725 }
726
727 return HILINK_SAL_OK;
728 }
729
HILINK_ScanAP(const HILINK_APScanParam * param)730 int HILINK_ScanAP(const HILINK_APScanParam *param)
731 {
732 if (param == NULL) {
733 HILINK_SAL_ERROR("scan param invalid\r\n");
734 return HILINK_SAL_PARAM_INVALID;
735 }
736
737 /* 激活WiFi */
738 if (wifi_is_sta_enabled() != 1) {
739 if (wifi_sta_enable() != ERRCODE_SUCC) {
740 HILINK_SAL_ERROR("enable wifi fail\r\n");
741 return HILINK_SAL_SET_WIFI_ERR;
742 }
743 }
744 if ((get_wifi_recovery_type() != 0) && (g_offline_mode_scan_flag == 0)) {
745 wifi_scan_strategy_stru scan_strategy;
746 scan_strategy.scan_time = 105; /* 105: 单信道扫描停留时间105ms */
747 scan_strategy.scan_cnt = 2; /* 2: 每个信道扫描2次 */
748 scan_strategy.single_probe_send_times = 1; /* 1: 单信道扫描每次发送一个probe request */
749 scan_strategy.reserved = 0;
750 if (wifi_sta_set_scan_policy(IFTYPE_STA, &scan_strategy) != ERRCODE_SUCC) {
751 HILINK_SAL_ERROR("sta_set_scan_policy failed\r\n");
752 }
753 g_offline_mode_scan_flag = 1; /* 1: 已完成离线优化模式扫描策略设置 */
754 }
755
756 if (RegisterWifiEventToOhos() != HILINK_SAL_OK) {
757 HILINK_SAL_ERROR("register wifi event fail\r\n");
758 return HILINK_SAL_SET_WIFI_ERR;
759 }
760
761 /* 指定WiFi的ssid进行扫描 */
762 g_isStaScanSuccess = false;
763
764 /* 组装扫描参数，填充SSID */
765 wifi_scan_params_stru scanParams;
766 (void)memset_s(&scanParams, sizeof(scanParams), 0, sizeof(scanParams));
767 int ret = BuildScanParam(param, &scanParams);
768 if (ret != HILINK_SAL_OK) {
769 HILINK_SAL_ERROR("build scan param failed\r\n");
770 return ret;
771 }
772 if (wifi_sta_scan_advance(&scanParams) != ERRCODE_SUCC) {
773 HILINK_SAL_ERROR("wifi advance scan fail\r\n");
774 return HILINK_SAL_SCAN_WIFI_ERR;
775 }
776 (void)memset_s(&scanParams, sizeof(scanParams), 0, sizeof(scanParams));
777
778 return HILINK_SAL_OK;
779 }
780
GetScanWifiResultList(wifi_scan_info_stru ** list,unsigned int * listSize)781 static int GetScanWifiResultList(wifi_scan_info_stru **list, unsigned int *listSize)
782 {
783 unsigned int size = WIFI_SCAN_AP_LIMIT;
784 wifi_scan_info_stru *result = (wifi_scan_info_stru *)HILINK_Malloc(sizeof(wifi_scan_info_stru) * size);
785 if (result == NULL) {
786 HILINK_SAL_ERROR("malloc error\r\n");
787 return HILINK_SAL_MALLOC_ERR;
788 }
789 (void)memset_s(result, sizeof(wifi_scan_info_stru) * size, 0, sizeof(wifi_scan_info_stru) * size);
790
791 if (wifi_sta_get_scan_info(result, &size) != ERRCODE_SUCC) {
792 HILINK_SAL_ERROR("Get wifi scan info fail.\r\n");
793 HILINK_Free(result);
794 return HILINK_SAL_SCAN_WIFI_ERR;
795 }
796 *list = result;
797 *listSize = size;
798 return HILINK_SAL_OK;
799 }
800
CopyScanWifiResultList(HILINK_APList * scanList,wifi_scan_info_stru * result,unsigned int resSize)801 static int CopyScanWifiResultList(HILINK_APList *scanList, wifi_scan_info_stru *result, unsigned int resSize)
802 {
803 HILINK_APInfo *info = (HILINK_APInfo *)HILINK_Malloc(sizeof(HILINK_APInfo) * resSize);
804 if (info == NULL) {
805 HILINK_SAL_ERROR("malloc error\r\n");
806 return HILINK_SAL_MALLOC_ERR;
807 }
808 (void)memset_s(info, sizeof(HILINK_APInfo) * resSize, 0, sizeof(HILINK_APInfo) * resSize);
809 for (unsigned int i = 0; i < resSize; i++) {
810 if ((strcpy_s(info[i].ssid, sizeof(info[i].ssid), result[i].ssid) != EOK) ||
811 (memcpy_s(info[i].bssid, sizeof(info[i].bssid), result[i].bssid, sizeof(result[i].bssid)) != EOK)) {
812 HILINK_Free(info);
813 return HILINK_SAL_MEMCPY_ERR;
814 }
815 info[i].rssi = result[i].rssi;
816 info[i].band = result[i].band;
817 info[i].securityType = result[i].security_type;
818 info[i].frequency = result[i].channel_num;
819 }
820 scanList->apList = info;
821 scanList->num = resSize;
822 return HILINK_SAL_OK;
823 }
824
HILINK_GetAPScanResult(HILINK_APList * scanList)825 int HILINK_GetAPScanResult(HILINK_APList *scanList)
826 {
827 if (scanList == NULL) {
828 HILINK_SAL_ERROR("invalid params\r\n");
829 return HILINK_SAL_PARAM_INVALID;
830 }
831
832 if (!g_isStaScanSuccess) {
833 HILINK_SAL_NOTICE("AP scanning is not complete.\r\n");
834 return WIFI_SCANNING;
835 }
836
837 unsigned int size = 0;
838 wifi_scan_info_stru *scanInfo = NULL;
839 int ret = GetScanWifiResultList(&scanInfo, &size);
840 if (ret != HILINK_SAL_OK) {
841 HILINK_SAL_ERROR("get scan wifi list failed, ret = %d.\r\n", ret);
842 return ret;
843 }
844
845 HILINK_SAL_NOTICE("scan result size: %u\r\n", size);
846 if (size == 0) {
847 HILINK_Free(scanInfo);
848 scanList->apList = NULL;
849 scanList->num = 0;
850 return HILINK_SAL_OK;
851 }
852
853 ret = CopyScanWifiResultList(scanList, scanInfo, size);
854 if (ret != HILINK_SAL_OK) {
855 HILINK_SAL_ERROR("copy wifi list failed, ret = %d.\r\n", ret);
856 (void)memset_s(scanInfo, size * sizeof(wifi_scan_info_stru), 0, size * sizeof(wifi_scan_info_stru));
857 HILINK_Free(scanInfo);
858 scanInfo = NULL;
859 return ret;
860 }
861
862 (void)memset_s(scanInfo, size * sizeof(wifi_scan_info_stru), 0, size * sizeof(wifi_scan_info_stru));
863 HILINK_Free(scanInfo);
864 scanInfo = NULL;
865
866 return HILINK_SAL_OK;
867 }
868
HILINK_ConnectWiFi(void)869 int HILINK_ConnectWiFi(void)
870 {
871 int ret;
872 wifi_sta_config_stru config;
873 (void)memset_s(&config, sizeof(config), 0, sizeof(config));
874 wifi_scan_info_stru info;
875 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
876
877 if (wifi_is_sta_enabled() != 1) {
878 if (wifi_sta_enable() != ERRCODE_SUCC) {
879 HILINK_SAL_ERROR("enable wifi fail\r\n");
880 return HILINK_SAL_SET_WIFI_ERR;
881 }
882 }
883
884 if (RegisterWifiEventToOhos() != HILINK_SAL_OK) {
885 HILINK_SAL_ERROR("register wifi event fail\r\n");
886 return HILINK_SAL_SET_WIFI_ERR;
887 }
888
889 if (GetWifiConfigFromOhos(&config) != HILINK_SAL_OK) {
890 HILINK_SAL_ERROR("get wifi config fail\r\n");
891 return HILINK_SAL_GET_WIFI_INFO_ERR;
892 }
893
894 if (config.ssid[0] == '\0') {
895 HILINK_SAL_ERROR("ssid null\r\n");
896 return HILINK_SAL_GET_WIFI_INFO_ERR;
897 }
898
899 for (unsigned int i = 0; i < MAX_SCAN_TIMES; ++i) {
900 if (AdvanceScanWifiByOhos(&config) != HILINK_SAL_OK) {
901 HILINK_SAL_ERROR("advance scan wifi fail\r\n");
902 (void)memset_s(&config, sizeof(wifi_sta_config_stru), 0, sizeof(wifi_sta_config_stru));
903 return HILINK_SAL_SCAN_WIFI_ERR;
904 }
905 if (GetScanWifiResultFromOhos(&config, &info)) {
906 SetSecurityTypeByScanInfo(&config, &info);
907 break;
908 }
909 HILINK_SAL_NOTICE("not find target wifi, try again\r\n");
910 }
911
912 /* 1 5 10 5 ：非离线优化模式使能自动重连，单次重连超时时间 5秒，重连间隔10秒 ，最大重连次数3600次 */
913 if (wifi_sta_set_reconnect_policy(1, 5, 10, 3600) != ERRCODE_SUCC) {
914 HILINK_SAL_ERROR("set reconnect policy error.\r\n");
915 }
916
917 config.ip_type = DHCP;
918 if (wifi_sta_connect(&config) != ERRCODE_SUCC) {
919 HILINK_SAL_ERROR("connect to wifi fail.\n");
920 return HILINK_SAL_CONENCT_WIFI_ERR;
921 }
922
923 if (sta_setup_dhcp() != 0) {
924 HILINK_SAL_ERROR("set sta dhcp failed\r\n");
925 return HILINK_SAL_CONENCT_WIFI_ERR;
926 }
927 return HILINK_SAL_OK;
928 }
929
HILINK_GetNetworkState(int * state)930 int HILINK_GetNetworkState(int *state)
931 {
932 if (state == NULL) {
933 HILINK_SAL_WARN("invalid param\r\n");
934 return HILINK_SAL_PARAM_INVALID;
935 }
936
937 wifi_linked_info_stru info;
938 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
939 /* 获取不到linkinfo时认为网络未连接 */
940 if (wifi_sta_get_ap_info(&info) != ERRCODE_SUCC) {
941 info.conn_state = WIFI_DISCONNECTED;
942 }
943
944 *state = (info.conn_state == WIFI_CONNECTED) ? 1 : 0;
945 return HILINK_SAL_OK;
946 }
947
HILINK_GetWiFiBssid(unsigned char * bssid,unsigned char * bssidLen)948 int HILINK_GetWiFiBssid(unsigned char *bssid, unsigned char *bssidLen)
949 {
950 if ((bssid == NULL) || (bssidLen == NULL) || (*bssidLen == 0)) {
951 HILINK_SAL_WARN("invalid param\r\n");
952 return HILINK_SAL_PARAM_INVALID;
953 }
954
955 wifi_linked_info_stru info;
956 (void)memset_s(&info, sizeof(wifi_linked_info_stru), 0, sizeof(wifi_linked_info_stru));
957
958 if (wifi_sta_get_ap_info(&info) != ERRCODE_SUCC) {
959 HILINK_SAL_ERROR("get wifi linked info fail\r\n");
960 return HILINK_SAL_GET_WIFI_INFO_ERR;
961 }
962
963 if (memcpy_s(bssid, *bssidLen, info.bssid, sizeof(info.bssid)) != EOK) {
964 HILINK_SAL_ERROR("memcpy error\r\n");
965 return HILINK_SAL_MEMCPY_ERR;
966 }
967
968 *bssidLen = WIFI_MAC_LEN;
969 return HILINK_SAL_OK;
970 }
971
HILINK_GetWiFiRssi(signed char * rssi)972 int HILINK_GetWiFiRssi(signed char *rssi)
973 {
974 if (rssi == NULL) {
975 HILINK_SAL_WARN("invalid param\r\n");
976 return HILINK_SAL_PARAM_INVALID;
977 }
978
979 wifi_linked_info_stru info;
980 (void)memset_s(&info, sizeof(wifi_linked_info_stru), 0, sizeof(wifi_linked_info_stru));
981 if (wifi_sta_get_ap_info(&info) != ERRCODE_SUCC) {
982 HILINK_SAL_ERROR("get wifi linked info fail\r\n");
983 return HILINK_SAL_GET_WIFI_INFO_ERR;
984 }
985
986 *rssi = (signed char)info.rssi;
987 return HILINK_SAL_OK;
988 }