1 /*
2 * Copyright (c) 2022 FuZhou Lockzhiner Electronic Co., Ltd. All rights reserved.
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 <securec.h>
17 #include <stdio.h>
18 #include <stdlib.h>
19
20 #include "lwip/if_api.h"
21 #include "lwip/netifapi.h"
22 #include "wifi_device_util.h"
23 #include "wifi_hotspot_config.h"
24 #include "utils_file.h"
25
26 #include "lz_hardware.h"
27 #include "wifi_device.h"
28
29 #define WIFI_DEVICE_TAG "WIFI_DEVICE"
30
31 static WifiDeviceConfig g_wifiConfigs[WIFI_MAX_CONFIG_SIZE] = {
32 {0}, {0}, {0}, 0, WIFI_CONFIG_INVALID, 0, 0, UNKNOWN, {0, 0, {0, 0}, 0}
33 };
34 static int g_networkId = -1;
35 static int g_staStatus = WIFI_STA_NOT_ACTIVE;
36 static int g_scan_flag = 0;
37 static WifiEvent *g_event = NULL;
38
EnableWifi(void)39 WifiErrorCode EnableWifi(void)
40 {
41 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
42 return ERROR_WIFI_UNKNOWN;
43 }
44
45 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
46 return ERROR_WIFI_UNKNOWN;
47 }
48
49 if (g_staStatus == WIFI_STA_ACTIVE) {
50 return ERROR_WIFI_BUSY;
51 }
52
53 if (WifiEnable() != WIFI_SUCCESS) {
54 return ERROR_WIFI_UNKNOWN;
55 }
56
57 if (WifiStartStation() != WIFI_SUCCESS) {
58 return ERROR_WIFI_UNKNOWN;
59 }
60
61 g_staStatus = WIFI_STA_ACTIVE;
62 return WIFI_SUCCESS;
63 }
64
DisableWifi(void)65 WifiErrorCode DisableWifi(void)
66 {
67 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
68 return ERROR_WIFI_UNKNOWN;
69 }
70
71 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
72 return ERROR_WIFI_UNKNOWN;
73 }
74
75 if (g_staStatus == WIFI_STA_NOT_ACTIVE) {
76 return ERROR_WIFI_NOT_STARTED;
77 }
78
79 if (WifiDisable() != WIFI_SUCCESS) {
80 return ERROR_WIFI_UNKNOWN;
81 }
82
83 g_staStatus = WIFI_STA_NOT_ACTIVE;
84 return WIFI_SUCCESS;
85 }
86
IsWifiActive(void)87 int IsWifiActive(void)
88 {
89 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
90 return ERROR_WIFI_UNKNOWN;
91 }
92 int ret = g_staStatus;
93 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
94 return ERROR_WIFI_UNKNOWN;
95 }
96
97 return ret;
98 }
99
Scan(void)100 WifiErrorCode Scan(void)
101 {
102 /* 定义扫描等待时长，以秒为单位 */
103 unsigned int sleep_seconds = 5;
104
105 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
106 return ERROR_WIFI_UNKNOWN;
107 }
108
109 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
110 return ERROR_WIFI_UNKNOWN;
111 }
112
113 if (WifiStartScan() != WIFI_SUCCESS) {
114 return ERROR_WIFI_UNKNOWN;
115 }
116 g_scan_flag = 1;
117 sleep(sleep_seconds);
118 if (g_event) {
119 g_event->OnWifiScanStateChanged(1, 0);
120 }
121 return WIFI_SUCCESS;
122 }
123
AdvanceScan(WifiScanParams * params)124 WifiErrorCode AdvanceScan(WifiScanParams *params)
125 {
126 unsigned int sleep_sec = 5;
127
128 if (params == NULL) {
129 return ERROR_WIFI_UNKNOWN;
130 }
131
132 if (params->scanType == WIFI_BSSID_SCAN) {
133 if (params->bssid[0] == 0) {
134 return ERROR_WIFI_UNKNOWN;
135 }
136 }
137
138 if (params->scanType == WIFI_SSID_SCAN) {
139 if (params->ssidLen == 0) {
140 return ERROR_WIFI_UNKNOWN;
141 }
142 }
143
144 if (params->scanType == WIFI_FREQ_SCAN) {
145 if (params->freqs == 0) {
146 return ERROR_WIFI_UNKNOWN;
147 }
148 }
149
150 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
151 return ERROR_WIFI_UNKNOWN;
152 }
153
154 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
155 return ERROR_WIFI_UNKNOWN;
156 }
157
158 if (LockWifiEventLock() != WIFI_SUCCESS) {
159 return ERROR_WIFI_UNKNOWN;
160 }
161 if (UnlockWifiEventLock() != WIFI_SUCCESS) {
162 return ERROR_WIFI_UNKNOWN;
163 }
164
165 if (WifiStartScan() != WIFI_SUCCESS) {
166 return ERROR_WIFI_UNKNOWN;
167 }
168 g_scan_flag = 1;
169 sleep(sleep_sec);
170 if (g_event) {
171 g_event->OnWifiScanStateChanged(1, 0);
172 }
173
174 return WIFI_SUCCESS;
175 }
176
GetScanInfoList(WifiScanInfo * result,unsigned int * size)177 WifiErrorCode GetScanInfoList(WifiScanInfo* result, unsigned int* size)
178 {
179 WifiScanResult *scanResult;
180 unsigned int scanSize;
181
182 if (result == NULL || size == NULL || *size == 0) {
183 return ERROR_WIFI_INVALID_ARGS;
184 }
185
186 if (WifiGetScanResult(&scanResult, &scanSize) != WIFI_SUCCESS) {
187 if (g_scan_flag == 0) {
188 *size = 0;
189 return WIFI_SUCCESS;
190 }
191
192 return ERROR_WIFI_UNKNOWN;
193 }
194
195 if (g_scan_flag) {
196 g_scan_flag = 0;
197 }
198
199 for (int i = 0; i < scanSize; i++) {
200 memcpy_s(result[i].ssid, WIFI_MAX_SSID_LEN, scanResult[i].ssid, WIFI_MAX_SSID_LEN);
201 memcpy_s(result[i].bssid, WIFI_MAC_LEN, scanResult[i].bssid, WIFI_MAC_LEN);
202 result[i].securityType = scanResult[i].securityType;
203 result[i].rssi = scanResult[i].rssi;
204 result[i].band = scanResult[i].band;
205 result[i].frequency = scanResult[i].frequency;
206 }
207
208 *size = scanSize;
209 return WIFI_SUCCESS;
210 }
211
AddDeviceConfig(const WifiDeviceConfig * config,int * result)212 WifiErrorCode AddDeviceConfig(const WifiDeviceConfig* config, int* result)
213 {
214 if (config == NULL || result == NULL) {
215 return ERROR_WIFI_INVALID_ARGS;
216 }
217
218 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
219 return ERROR_WIFI_UNKNOWN;
220 }
221
222 int netId = WIFI_CONFIG_INVALID;
223 for (int i = 0; i < WIFI_MAX_CONFIG_SIZE; i++) {
224 if (g_wifiConfigs[i].netId != i) {
225 netId = i;
226 break;
227 }
228 }
229
230 if (netId == WIFI_CONFIG_INVALID) {
231 LZ_HARDWARE_LOGD(WIFI_DEVICE_TAG, "AddDeviceConfig: wifi config is full, delete one first");
232 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
233 return ERROR_WIFI_UNKNOWN;
234 }
235 return ERROR_WIFI_BUSY;
236 }
237
238 int err = memcpy_s(&g_wifiConfigs[netId], sizeof(WifiDeviceConfig), config, sizeof(WifiDeviceConfig));
239 if (err != EOK) {
240 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
241 return ERROR_WIFI_UNKNOWN;
242 }
243 LZ_HARDWARE_LOGD(WIFI_DEVICE_TAG, "AddDeviceConfig: memcpy failed, err = %d", err);
244 return ERROR_WIFI_UNKNOWN;
245 }
246
247 g_wifiConfigs[netId].netId = netId;
248
249 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
250 return ERROR_WIFI_UNKNOWN;
251 }
252
253 *result = netId;
254 return WIFI_SUCCESS;
255 }
256
GetDeviceConfigs(WifiDeviceConfig * result,unsigned int * size)257 WifiErrorCode GetDeviceConfigs(WifiDeviceConfig* result, unsigned int* size)
258 {
259 if (result == NULL || size == NULL) {
260 return ERROR_WIFI_INVALID_ARGS;
261 }
262
263 unsigned int retIndex = 0;
264
265 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
266 return ERROR_WIFI_UNKNOWN;
267 }
268
269 for (int i = 0; i < WIFI_MAX_CONFIG_SIZE; i++) {
270 if (g_wifiConfigs[i].netId != i) {
271 continue;
272 }
273
274 int err = memcpy_s(&result[retIndex], sizeof(WifiDeviceConfig), &g_wifiConfigs[i], sizeof(WifiDeviceConfig));
275 if (err != EOK) {
276 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
277 return ERROR_WIFI_UNKNOWN;
278 }
279 LZ_HARDWARE_LOGD(WIFI_DEVICE_TAG, "GetDeviceConfig: memcpy failed, err = %d", err);
280 return ERROR_WIFI_UNKNOWN;
281 }
282
283 retIndex++;
284 if (*size < retIndex) {
285 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
286 return ERROR_WIFI_UNKNOWN;
287 }
288 return ERROR_WIFI_INVALID_ARGS;
289 }
290 }
291
292 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
293 return ERROR_WIFI_UNKNOWN;
294 }
295
296 if (retIndex == 0) {
297 return ERROR_WIFI_NOT_AVAILABLE;
298 }
299
300 *size = retIndex;
301 return WIFI_SUCCESS;
302 }
303
ConnectTo(int networkId)304 WifiErrorCode ConnectTo(int networkId)
305 {
306 if (networkId >= WIFI_MAX_CONFIG_SIZE || networkId < 0) {
307 return ERROR_WIFI_INVALID_ARGS;
308 }
309
310 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
311 return ERROR_WIFI_UNKNOWN;
312 }
313
314 if (g_staStatus != WIFI_STA_ACTIVE) {
315 return ERROR_WIFI_UNKNOWN;
316 }
317
318 if (g_wifiConfigs[networkId].netId != networkId) {
319 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
320 return ERROR_WIFI_UNKNOWN;
321 }
322 return ERROR_WIFI_NOT_AVAILABLE;
323 }
324
325 g_networkId = networkId;
326
327 if (WifiConnect(g_wifiConfigs[networkId].ssid,
328 g_wifiConfigs[networkId].preSharedKey) != WIFI_SUCCESS) {
329 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
330 return ERROR_WIFI_UNKNOWN;
331 }
332 return ERROR_WIFI_UNKNOWN;
333 }
334
335 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
336 return ERROR_WIFI_UNKNOWN;
337 }
338
339 if (LockWifiEventLock() != WIFI_SUCCESS) {
340 return ERROR_WIFI_UNKNOWN;
341 }
342 if (UnlockWifiEventLock() != WIFI_SUCCESS) {
343 return ERROR_WIFI_UNKNOWN;
344 }
345 return WIFI_SUCCESS;
346 }
347
Disconnect(void)348 WifiErrorCode Disconnect(void)
349 {
350 if (g_staStatus != WIFI_STA_ACTIVE) {
351 return ERROR_WIFI_UNKNOWN;
352 }
353
354 if (WifiDisconnect(0) != WIFI_SUCCESS) {
355 return ERROR_WIFI_UNKNOWN;
356 }
357 return WIFI_SUCCESS;
358 }
359
RemoveDevice(int networkId)360 WifiErrorCode RemoveDevice(int networkId)
361 {
362 if (networkId >= WIFI_MAX_CONFIG_SIZE || networkId < 0) {
363 return ERROR_WIFI_INVALID_ARGS;
364 }
365 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
366 return ERROR_WIFI_UNKNOWN;
367 }
368
369 if (memset_s(&g_wifiConfigs[networkId], sizeof(WifiDeviceConfig),
370 0, sizeof(WifiDeviceConfig)) != EOK) {
371 LZ_HARDWARE_LOGE(WIFI_DEVICE_TAG, "RemoveDevice: memset failed");
372 }
373 g_wifiConfigs[networkId].netId = WIFI_CONFIG_INVALID;
374
375 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
376 return ERROR_WIFI_UNKNOWN;
377 }
378 return WIFI_SUCCESS;
379 }
380
GetLocalWifiGw(int * const gw)381 int GetLocalWifiGw(int *const gw)
382 {
383 struct netif *netif = netif_find("wlan0");
384 if (netif == NULL) {
385 LZ_HARDWARE_LOGE(WIFI_DEVICE_TAG, "GetLocalWifiGw: netif get fail\n");
386 return ERROR_WIFI_UNKNOWN;
387 }
388
389 *gw = ip_addr_get_ip4_u32(&netif->gw);
390 return WIFI_SUCCESS;
391 }
392
SetLocalWifiGw(void)393 int SetLocalWifiGw(void)
394 {
395 int index_max = 10;
396 ip4_addr_t gw;
397 int i;
398 struct netif *netif;
399
400 for (i = 0; i < index_max; i++) {
401 netif = netif_get_by_index(i);
402 if (netif != NULL) {
403 LZ_HARDWARE_LOGE(WIFI_DEVICE_TAG, "%c %c num:%d %s",
404 netif->name[0], netif->name[1], netif->num,
405 inet_ntoa(ip_addr_get_ip4_u32(&netif->ip_addr)));
406 }
407 }
408
409 netif = netif_find("wlan0");
410 if (netif == NULL) {
411 LZ_HARDWARE_LOGE(WIFI_DEVICE_TAG, "SetLocalWifiGw: netif get fail\n");
412 return ERROR_WIFI_UNKNOWN;
413 }
414 IP4_ADDR(&gw, 0, 0, 0, 0);
415 netifapi_netif_set_default(netif);
416 return WIFI_SUCCESS;
417 }
418
GetLocalWifiNetmask(int * const netmask)419 int GetLocalWifiNetmask(int *const netmask)
420 {
421 struct netif *netif = netif_find("wlan0");
422 if (netif == NULL) {
423 LZ_HARDWARE_LOGE(WIFI_DEVICE_TAG, "GetLocalWifiNetmask: netif get fail\n");
424 return ERROR_WIFI_UNKNOWN;
425 }
426
427 *netmask = ip_addr_get_ip4_u32(&netif->netmask);
428 return WIFI_SUCCESS;
429 }
430
GetLocalWifiIp(int * const ip)431 static int GetLocalWifiIp(int * const ip)
432 {
433 struct netif *netif = netif_find("wlan0");
434 if (netif == NULL) {
435 LZ_HARDWARE_LOGE(WIFI_DEVICE_TAG, "GetLocalWifiIp: netif get fail\n");
436 return ERROR_WIFI_UNKNOWN;
437 }
438
439 *ip = ip_addr_get_ip4_u32(&netif->ip_addr);
440 return WIFI_SUCCESS;
441 }
442
GetLinkedInfo(WifiLinkedInfo * result)443 WifiErrorCode GetLinkedInfo(WifiLinkedInfo* result)
444 {
445 WifiConnInfo connInfo;
446
447 if (result == NULL) {
448 return ERROR_WIFI_INVALID_ARGS;
449 }
450
451 if (WifiGetConnectInfo(&connInfo) != WIFI_SUCCESS) {
452 return ERROR_WIFI_UNKNOWN;
453 }
454
455 if (connInfo.status == LZ_HARDWARE_WIFI_CONNECTED) {
456 result->connState = WIFI_CONNECTED;
457 result->rssi = 0;
458 } else {
459 result->connState = WIFI_DISCONNECTED;
460 }
461
462 if (GetLocalWifiIp(&(result->ipAddress)) != EOK) {
463 return ERROR_WIFI_UNKNOWN;
464 }
465
466 return WIFI_SUCCESS;
467 }
468
RegisterWifiEvent(WifiEvent * event)469 WifiErrorCode RegisterWifiEvent(WifiEvent* event)
470 {
471 if (event == NULL) {
472 return ERROR_WIFI_INVALID_ARGS;
473 }
474 g_event = event;
475 g_event->OnWifiScanStateChanged(1, 0);
476 return WIFI_SUCCESS;
477 }
478
UnRegisterWifiEvent(const WifiEvent * event)479 WifiErrorCode UnRegisterWifiEvent(const WifiEvent* event)
480 {
481 if (event == NULL) {
482 return ERROR_WIFI_INVALID_ARGS;
483 }
484
485 if (LockWifiEventLock() != WIFI_SUCCESS) {
486 return ERROR_WIFI_UNKNOWN;
487 }
488 g_event = NULL;
489 if (UnlockWifiEventLock() != WIFI_SUCCESS) {
490 return ERROR_WIFI_UNKNOWN;
491 }
492 return WIFI_SUCCESS;
493 }
494
GetDeviceMacAddress(unsigned char * result)495 WifiErrorCode GetDeviceMacAddress(unsigned char* result)
496 {
497 if (result == NULL) {
498 return ERROR_WIFI_INVALID_ARGS;
499 }
500
501 return WIFI_SUCCESS;
502 }
503