1 // Copyright (C) 2022 Beken Corporation
2 //
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 "stdbool.h"
16 #include "wifi_device_util.h"
17 #include "wifi_device.h"
18 #include <securec.h>
19 #include "wifi_hotspot_config.h"
20 #include "utils_file.h"
21
22 #include <common/bk_err.h>
23 #include <modules/wifi.h>
24 #include <components/event.h>
25 #include <components/netif.h>
26
27 #define MAX_STORE_FILE_LEN 8
28
29 typedef struct bk_msg
30 {
31 void *data;
32 int event_id;
33 int event_module;
34 }BKMSG;
35
36 static int g_wifiStaStatus = WIFI_STA_NOT_ACTIVE;
37 static wifi_scan_result_t scan_apList = {0,0};
38 static WifiDeviceConfig g_wifiConfigs[WIFI_MAX_CONFIG_SIZE] = {
39 [0 ... (WIFI_MAX_CONFIG_SIZE-1)] = {{0}, {0}, {0}, 0, WIFI_CONFIG_INVALID, 0, 0}
40 };
41 static WifiEvent * g_wifiEvents[WIFI_MAX_EVENT_SIZE] = {0};
42 static const char wifi_store_filename[MAX_STORE_FILE_LEN] = "ApInfo";
43
44
45
46 #if 0
47 static WifiEvent g_wifitest ={0};
48 static void testOnWifiScanStateChangedHandler(int state, int size)
49 {
50 bk_printf("====%s,state:%d,size:%d===\r\n",__FUNCTION__,state,size);
51 }
52 static void testOnWifiConnectionChangedHandler(int state, WifiLinkedInfo* info)
53 {
54 bk_printf("====%s,state:%d===\r\n",__FUNCTION__,state);
55 }
56
57 #endif
58
59
60 #define MAC_LEN 6
61
62 struct sta_list {
63 struct sta_list *next;
64 unsigned char value[MAC_LEN];
65 };
66
67 struct sta_list *sta_info = NULL;
68
same_mac(unsigned char * mac1,unsigned char * mac2)69 static int same_mac(unsigned char* mac1, unsigned char* mac2) {
70 int i;
71 for (i = 0; i < MAC_LEN; i++)
72 if (mac1[i] != mac2[i])
73 return 0;
74 return 1;
75 }
76
add_sta(unsigned char * value)77 static void add_sta(unsigned char* value) {
78 struct sta_list *new = malloc(sizeof(struct sta_list));
79 if (!new)
80 return;
81
82 memcpy(new->value, value, MAC_LEN);
83 new->next = sta_info;
84 sta_info = new;
85 }
86
rm_sta(unsigned char * value)87 static void rm_sta(unsigned char* value) {
88 struct sta_list *tmp;
89 struct sta_list *prev;
90
91 if (!sta_info) {
92 printf("no entry for %d found\n", value[0]);
93 return;
94 }
95
96 if (same_mac(sta_info->value, value)) {
97 tmp = sta_info->next;
98 free(sta_info);
99 sta_info = tmp;
100 return;
101 }
102
103 prev = sta_info;
104 tmp = sta_info->next;
105 while (tmp && !same_mac(tmp->value, value)) {
106 prev = tmp;
107 tmp = tmp->next;
108 }
109
110 if (!tmp) {
111 printf("no entry for %d found\n", value[0]);
112 return;
113 }
114
115 prev->next = tmp->next;
116 free(tmp);
117 }
118
GetApInfo(StationInfo * result,unsigned int * size)119 WifiErrorCode GetApInfo(StationInfo* result, unsigned int* size) {
120 int cnt = 0;
121 struct sta_list *tmp;
122
123 tmp = sta_info;
124 while(tmp) {
125 memcpy(result[cnt].macAddress, tmp->value, MAC_LEN);
126 result[cnt].ipAddress = 0x0100007f; //fake
127 cnt++;
128 if (cnt >= *size)
129 break;
130 tmp = tmp->next;
131 }
132 *size = cnt;
133
134 return WIFI_SUCCESS;
135 }
136
137
138
DispatchScanStateChangeEvent(const void * evt,const WifiEvent * hosEvent)139 static void DispatchScanStateChangeEvent(const void *evt, const WifiEvent* hosEvent)
140 {
141 int size = 0;
142 BKMSG *msg = (BKMSG *)evt;
143 if(hosEvent->OnWifiScanStateChanged == NULL)
144 return;
145
146 if(msg == NULL)
147 {
148 hosEvent->OnWifiScanStateChanged(WIFI_STATE_NOT_AVAILABLE, 0);
149 return;
150 }
151 if(scan_apList.aps != NULL)
152 {
153 bk_wifi_scan_free_result(&scan_apList);
154 }
155
156 if (bk_wifi_scan_get_result(&scan_apList) == 0)
157 {
158 size = scan_apList.ap_num;
159 }
160
161 hosEvent->OnWifiScanStateChanged(WIFI_STATE_AVAILABLE, size);
162 return;
163 }
DispatchStaConnectEvent(const void * evt,const WifiEvent * hosEvent)164 static void DispatchStaConnectEvent(const void *evt, const WifiEvent* hosEvent)
165 {
166 WifiLinkedInfo info = {0};
167 BKMSG *msg = (BKMSG *)evt;
168
169 if(hosEvent->OnWifiConnectionChanged == NULL)
170 return;
171
172 if(msg->event_id == EVENT_WIFI_STA_CONNECTED)
173 {
174 GetLinkedInfo(&info);
175 hosEvent->OnWifiConnectionChanged(WIFI_STATE_AVAILABLE, &info);
176 return;
177 }
178 else
179 {
180 wifi_event_sta_disconnected_t *sta_disconnected = (wifi_event_sta_disconnected_t *)msg->data;
181 bk_printf("STA disconnected ,reason(%d)\r\n",sta_disconnected->disconnect_reason);
182 hosEvent->OnWifiConnectionChanged(WIFI_STATE_NOT_AVAILABLE, NULL);
183 }
184
185 }
186
DispatchAPConnectEvent(const void * evt,const WifiEvent * hosEvent)187 static void DispatchAPConnectEvent(const void *evt, const WifiEvent* hosEvent)
188 {
189 StationInfo info = {0};
190 BKMSG *msg = (BKMSG *)evt;
191 wifi_event_ap_disconnected_t *ap_disconnected;
192 wifi_event_ap_connected_t *ap_connected;
193 bk_printf("======dispatch event %d :======\r\n",msg->event_id);
194 if(msg->event_id == EVENT_WIFI_AP_CONNECTED)
195 {
196 if(hosEvent->OnHotspotStaJoin == NULL)
197 return;
198
199 ap_connected = (wifi_event_ap_connected_t *)msg->data;
200 add_sta(ap_connected->mac);
201 memcpy(info.macAddress, ap_connected->mac, WIFI_MAC_LEN);
202 hosEvent->OnHotspotStaJoin(&info);
203 return;
204 }
205 else
206 {
207 if(hosEvent->OnHotspotStaLeave == NULL)
208 return;
209 ap_disconnected = (wifi_event_ap_disconnected_t *)msg->data;
210 rm_sta(ap_disconnected->mac);
211 memcpy(info.macAddress, ap_disconnected->mac, WIFI_MAC_LEN);
212 hosEvent->OnHotspotStaLeave(&info);
213 }
214 }
DispatchEvent(void * BkEvent,const WifiEvent * hosEvent)215 static void DispatchEvent(void* BkEvent, const WifiEvent* hosEvent)
216 {
217 BKMSG *msg = (BKMSG *)BkEvent;
218
219 switch(msg->event_id)
220 {
221 case EVENT_WIFI_STA_CONNECTED:
222 case EVENT_WIFI_STA_DISCONNECTED:
223 DispatchStaConnectEvent(BkEvent, hosEvent);
224 break;
225
226 case EVENT_WIFI_AP_CONNECTED:
227 case EVENT_WIFI_AP_DISCONNECTED:
228 DispatchAPConnectEvent(BkEvent, hosEvent);
229 break;
230 case EVENT_WIFI_SCAN_DONE:
231 DispatchScanStateChangeEvent(BkEvent, hosEvent);
232 break;
233
234 default:
235
236 break;
237 }
238
239 }
240
241
BkWifiEventCb(void * arg,event_module_t event_module,int event_id,void * event_data)242 static void BkWifiEventCb(void *arg, event_module_t event_module, int event_id, void *event_data)
243 {
244 BKMSG msg;
245 msg.data = event_data;
246 msg.event_id = event_id;
247
248 for(int i=0; i<WIFI_MAX_EVENT_SIZE; i++)
249 {
250 if(g_wifiEvents[i] == NULL)
251 continue;
252 DispatchEvent(&msg, g_wifiEvents[i]);
253 }
254 }
255
256 //for ap start callback
DispatchApStartEvent(int state)257 void DispatchApStartEvent(int state)
258 {
259 for(int i=0; i<WIFI_MAX_EVENT_SIZE; i++)
260 {
261 if(g_wifiEvents[i] == NULL)
262 continue;
263 if(g_wifiEvents[i]->OnHotspotStateChanged == NULL)
264 continue;
265 g_wifiEvents[i]->OnHotspotStateChanged(state);
266 }
267 }
268
269
EnableWifi(void)270 WifiErrorCode EnableWifi(void)
271 {
272 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
273 return ERROR_WIFI_UNKNOWN;
274 }
275 if (g_wifiStaStatus == WIFI_STA_ACTIVE) {
276 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
277 return ERROR_WIFI_UNKNOWN;
278 }
279 return ERROR_WIFI_BUSY;
280 }
281
282 #if 0
283 wifi_init_config_t wifi_config = WIFI_DEFAULT_INIT_CONFIG();
284 bk_event_init();
285 bk_wifi_init(&wifi_config);
286 #endif
287 bk_printf("==%s 22===\r\n",__FUNCTION__);
288 g_wifiStaStatus = WIFI_STA_ACTIVE;
289 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
290 return ERROR_WIFI_UNKNOWN;
291 }
292
293 return WIFI_SUCCESS;
294 }
DisableWifi(void)295 WifiErrorCode DisableWifi(void)
296 {
297 if (LockWifiGlobalLock() != WIFI_SUCCESS) {
298 return ERROR_WIFI_UNKNOWN;
299 }
300
301 if (g_wifiStaStatus == WIFI_STA_NOT_ACTIVE) {
302 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
303 return ERROR_WIFI_UNKNOWN;
304 }
305 return ERROR_WIFI_NOT_STARTED;
306 }
307 #if 0
308 bk_event_deinit();
309 bk_wifi_deinit();
310 #endif
311 g_wifiStaStatus = WIFI_STA_NOT_ACTIVE;
312 if (UnlockWifiGlobalLock() != WIFI_SUCCESS) {
313 return ERROR_WIFI_UNKNOWN;
314 }
315
316 return WIFI_SUCCESS;
317 }
IsWifiActive(void)318 int IsWifiActive(void)
319 {
320 return g_wifiStaStatus;
321 }
322
Scan(void)323 WifiErrorCode Scan(void)
324 {
325 if (LockWifiEventLock() != WIFI_SUCCESS) {
326 return ERROR_WIFI_UNKNOWN;
327 }
328 for (int i = 0; i < WIFI_MAX_EVENT_SIZE; i++) {
329 if (g_wifiEvents[i] == NULL) {
330 continue;
331 }
332 DispatchScanStateChangeEvent(NULL, g_wifiEvents[i]);
333 }
334 if (UnlockWifiEventLock() != WIFI_SUCCESS) {
335 return ERROR_WIFI_UNKNOWN;
336 }
337 if(bk_wifi_scan_start(NULL) == 0)
338 return WIFI_SUCCESS;
339 else
340 return ERROR_WIFI_UNKNOWN;
341 }
342
GetScanInfoList(WifiScanInfo * result,unsigned int * size)343 WifiErrorCode GetScanInfoList(WifiScanInfo* result, unsigned int* size)
344 {
345 unsigned int i;
346 if( (result == NULL) || (size == NULL) || (size == 0) )
347 return ERROR_WIFI_INVALID_ARGS;
348
349 printf("YY : ap_num=%d\n", scan_apList.ap_num);
350
351 if(scan_apList.ap_num > *size)
352 return ERROR_WIFI_INVALID_ARGS;
353
354 for(i=0;i<scan_apList.ap_num;i++)
355 {
356 memcpy(result[i].ssid, scan_apList.aps[i].ssid, WIFI_MAX_SSID_LEN);
357 memcpy(result[i].bssid,scan_apList.aps[i].bssid, WIFI_MAC_LEN);
358 result[i].securityType = BKSecToHoSec(scan_apList.aps[i].security);
359 result[i].rssi = scan_apList.aps[i].rssi;
360 result[i].frequency = ChannelToFrequency(scan_apList.aps[i].channel);
361 result[i].band = HOTSPOT_BAND_TYPE_2G;
362 }
363 *size = scan_apList.ap_num;
364 //bk_wifi_scan_free_result(&scan_apList);
365
366 return WIFI_SUCCESS;
367 }
368
369
370
AddDeviceConfig(const WifiDeviceConfig * config,int * result)371 WifiErrorCode AddDeviceConfig(const WifiDeviceConfig* config, int* result)
372 {
373 int fd;
374 unsigned int file_size,write_size;
375 char file_name[MAX_STORE_FILE_LEN + 2];
376
377 if (config == NULL || result == NULL)
378 {
379 return ERROR_WIFI_INVALID_ARGS;
380 }
381 int netId = WIFI_CONFIG_INVALID;
382 //printf("AddDeviceonfig ssid=%s-%s\r\n",config->ssid,config->preSharedKey);
383 if (LockWifiGlobalLock() != WIFI_SUCCESS)
384 {
385 return ERROR_WIFI_UNKNOWN;
386 }
387
388 for (int i = 0; i < WIFI_MAX_CONFIG_SIZE; i++)
389 {
390 if (g_wifiConfigs[i].netId != i)
391 {
392 netId = i;
393 break;
394 }
395 }
396 if(netId == WIFI_CONFIG_INVALID)
397 {
398 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
399 {
400 return ERROR_WIFI_UNKNOWN;
401 }
402 return ERROR_WIFI_BUSY;
403 }
404 memcpy(&g_wifiConfigs[netId],config,sizeof(WifiDeviceConfig));
405 g_wifiConfigs[netId].netId = netId;
406
407 #if 1
408 /*save*/
409 snprintf(file_name, sizeof(file_name), "%s%02d",wifi_store_filename,netId);
410 fd = UtilsFileOpen(file_name, O_WRONLY_FS | O_CREAT_FS |O_TRUNC_FS, 0);
411 if(fd < 0)
412 return ERROR_WIFI_UNKNOWN;
413 file_size = sizeof(WifiDeviceConfig);
414 write_size = UtilsFileWrite(fd, (const char*)&g_wifiConfigs[netId], file_size);
415 UtilsFileClose(fd);
416 //bk_printf("====save:%s,%d,%d,%d==\r\n",file_name,netId,file_size,write_size);
417 if(write_size != file_size)
418 {
419 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
420 {
421 return ERROR_WIFI_UNKNOWN;
422 }
423 }
424 #endif
425 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
426 {
427 return ERROR_WIFI_UNKNOWN;
428 }
429 *result = netId;
430
431 return WIFI_SUCCESS;
432
433 }
434
GetDeviceConfigs(WifiDeviceConfig * result,unsigned int * size)435 WifiErrorCode GetDeviceConfigs(WifiDeviceConfig* result, unsigned int* size)
436 {
437 int fd;
438 unsigned int retIndex, i;
439 unsigned int file_size,read_size;
440 char file_name[MAX_STORE_FILE_LEN + 2];
441
442 if(result == NULL || size == NULL || *size == 0)
443 {
444 return ERROR_WIFI_INVALID_ARGS;
445 }
446
447 if (LockWifiGlobalLock() != WIFI_SUCCESS)
448 {
449 return ERROR_WIFI_UNKNOWN;
450 }
451 retIndex = 0;
452
453 #if 1
454 for(i=0; i<WIFI_MAX_CONFIG_SIZE; i++)
455 {
456 snprintf(file_name, sizeof(file_name), "%s%02d",wifi_store_filename,i);
457 if(0 !=UtilsFileStat(file_name,&file_size))
458 break;
459 fd = UtilsFileOpen(file_name,O_RDONLY_FS, 0);
460 if(fd < 0)
461 goto error_ret;
462 read_size = UtilsFileRead(fd, (char* )&g_wifiConfigs[i], file_size);
463 if(read_size != file_size)
464 goto error_ret;
465 UtilsFileClose(fd);
466 }
467 if(i == 0)
468 goto error_ret;
469 #else
470 i = WIFI_MAX_CONFIG_SIZE;
471 #endif
472
473 for (i = 0; i < WIFI_MAX_CONFIG_SIZE; i++) {
474 if (g_wifiConfigs[i].netId != WIFI_CONFIG_INVALID) {
475 memcpy(&result[retIndex], &g_wifiConfigs[i], sizeof(WifiDeviceConfig));
476 retIndex++;
477 if (retIndex >= *size)
478 break;
479 }
480 }
481
482 /*
483 while( retIndex < i )
484 {
485 memcpy(&result[retIndex], &g_wifiConfigs[retIndex], sizeof(WifiDeviceConfig));
486 retIndex++;
487 if(*size < retIndex)
488 {
489 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
490 {
491 return ERROR_WIFI_UNKNOWN;
492 }
493 return ERROR_WIFI_INVALID_ARGS;
494 }
495 }
496 */
497 error_ret:
498 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
499 {
500 return ERROR_WIFI_UNKNOWN;
501 }
502 if(retIndex == 0)
503 return ERROR_WIFI_NOT_AVAILABLE;
504
505
506
507 //for test
508
509 if(g_wifiConfigs[0].ssid == NULL)
510 return ERROR_WIFI_NOT_AVAILABLE;
511
512
513
514
515
516 *size = retIndex;
517 return WIFI_SUCCESS;
518
519 }
520
RemoveDevice(int networkId)521 WifiErrorCode RemoveDevice(int networkId)
522 {
523 char file_name[MAX_STORE_FILE_LEN + 2];
524 //int i,file_size;
525 //int fd;
526 if (networkId >= WIFI_MAX_CONFIG_SIZE || networkId < 0)
527 {
528 return ERROR_WIFI_INVALID_ARGS;
529 }
530
531 if (LockWifiGlobalLock() != WIFI_SUCCESS)
532 {
533 return ERROR_WIFI_UNKNOWN;
534 }
535
536 memset(&g_wifiConfigs[networkId], 0, sizeof(WifiDeviceConfig)) ;
537 g_wifiConfigs[networkId].netId = WIFI_CONFIG_INVALID;
538 #if 1
539 snprintf(file_name, sizeof(file_name), "%s%02d",wifi_store_filename,networkId);
540 UtilsFileDelete(file_name);
541 #endif
542 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
543 {
544 return ERROR_WIFI_UNKNOWN;
545 }
546
547 return WIFI_SUCCESS;
548 }
549
ConnectTo(int networkId)550 WifiErrorCode ConnectTo(int networkId)
551 {
552 int chan = 0;
553 int ret=0;
554 wifi_sta_config_t sta_config;
555 if (networkId >= WIFI_MAX_CONFIG_SIZE || networkId < 0)
556 {
557 return ERROR_WIFI_INVALID_ARGS;
558 }
559 if (LockWifiGlobalLock() != WIFI_SUCCESS)
560 {
561 return ERROR_WIFI_UNKNOWN;
562 }
563
564 if (g_wifiConfigs[networkId].netId != networkId)
565 {
566 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
567 {
568 return ERROR_WIFI_UNKNOWN;
569 }
570 return ERROR_WIFI_NOT_AVAILABLE;
571 }
572
573 if(NULL == strcpy(sta_config.ssid, g_wifiConfigs[networkId].ssid))
574 return ERROR_WIFI_NOT_AVAILABLE;
575 if(NULL == strcpy(sta_config.password, g_wifiConfigs[networkId].preSharedKey))
576 return ERROR_WIFI_NOT_AVAILABLE;
577 ret = memcpy_s(sta_config.bssid, sizeof(sta_config.bssid), g_wifiConfigs[networkId].bssid, sizeof(g_wifiConfigs[networkId].bssid));
578 sta_config.channel = FrequencyToChannel(g_wifiConfigs[networkId].freq);
579 if (UnlockWifiGlobalLock() != WIFI_SUCCESS)
580 {
581 return ERROR_WIFI_UNKNOWN;
582 }
583 if(ret != EOK)
584 return ERROR_WIFI_UNKNOWN;
585
586 if (LockWifiEventLock() != WIFI_SUCCESS)
587 {
588 return ERROR_WIFI_UNKNOWN;
589 }
590 // bk_printf("---ssid:%s,psw:%s,%d-----\r\n",sta_config.ssid,sta_config.password,sta_config.security);
591 // bk_printf("--bssid:%x,%x,%x,%x,%x--\r\n",sta_config.bssid[0],sta_config.bssid[1],sta_config.bssid[2],sta_config.bssid[3],sta_config.bssid[4]);
592
593 bk_wifi_sta_set_config(&sta_config);
594 bk_wifi_sta_start();
595 if (UnlockWifiEventLock() != WIFI_SUCCESS)
596 {
597 return ERROR_WIFI_UNKNOWN;
598 }
599 #if 1
600 //wait for connect result
601 int time_out_cnt = 15;
602 WifiLinkedInfo info ={0};
603 ret = ERROR_WIFI_NOT_AVAILABLE;
604
605 while(time_out_cnt --)
606 {
607 osDelay(500);//4//1s
608 GetLinkedInfo(&info);
609 if(info.connState == WIFI_CONNECTED)
610 {
611 bk_printf("--wifi connected--\r\n");
612 ret = WIFI_SUCCESS;
613 break;
614 }
615 }
616 #endif
617
618 return ret;
619 }
620
Disconnect(void)621 WifiErrorCode Disconnect(void)
622 {
623 int ret;
624 WifiLinkedInfo info ={0};
625
626 ret = GetLinkedInfo(&info);
627 if(ret != WIFI_SUCCESS)
628 return ret;
629 //printf("connState=%d, ssid=%s\n", info.connState, info.ssid);
630 bk_wifi_sta_stop();
631 if(info.connState != WIFI_CONNECTED)
632 return ERROR_WIFI_NOT_AVAILABLE;
633 return WIFI_SUCCESS;
634 }
635
636 extern unsigned int ipaddr_addr(const char *cp);
637
GetLinkedInfo(WifiLinkedInfo * result)638 WifiErrorCode GetLinkedInfo(WifiLinkedInfo* result)
639 {
640 wifi_link_status_t linkstat={0};
641 int ret;
642 netif_ip4_config_t config;
643 if(result == NULL)
644 return ERROR_WIFI_INVALID_ARGS;
645 if(bk_wifi_sta_get_link_status(&linkstat) != 0)
646 return ERROR_WIFI_UNKNOWN;
647
648 memcpy(result->ssid, linkstat.ssid, sizeof(linkstat.ssid));
649 memcpy(result->bssid, linkstat.bssid, WIFI_MAC_LEN);
650 result->connState = ((linkstat.state == 4) || (linkstat.state == 9) || (linkstat.state == 10)) ? WIFI_CONNECTED : WIFI_DISCONNECTED;
651 result->rssi = linkstat.rssi;
652 //printf("link info : ssid=%s, state=%d, rssi=%d\n", linkstat.ssid, linkstat.state, linkstat.rssi);
653 ret = bk_netif_get_ip4_config(NETIF_IF_STA, &config);
654 if (ret) {
655 printf("get ip failed\n");
656 return ERROR_WIFI_UNKNOWN;
657 }
658 result->ipAddress = ipaddr_addr(config.ip);
659 //printf("ip:0x%x\n",result->ipAddress);
660 return WIFI_SUCCESS;
661 }
662
RegisterWifiEvent(WifiEvent * event)663 WifiErrorCode RegisterWifiEvent(WifiEvent* event)
664 {
665 if(event == NULL)
666 return ERROR_WIFI_INVALID_ARGS;
667
668 int emptySlot = WIFI_CONFIG_INVALID;
669 if (LockWifiEventLock() != WIFI_SUCCESS)
670 {
671 return ERROR_WIFI_UNKNOWN;
672 }
673 for(int i=0; i<WIFI_MAX_EVENT_SIZE;i++)
674 {
675 if(g_wifiEvents[i] == event)
676 {
677 return ERROR_WIFI_INVALID_ARGS;
678 }
679 if(g_wifiEvents[i] != NULL)
680 {
681 continue;
682 }
683 emptySlot = i;
684 break;
685 }
686 if (emptySlot == WIFI_CONFIG_INVALID)
687 {
688 if (UnlockWifiEventLock() != WIFI_SUCCESS)
689 {
690 return ERROR_WIFI_UNKNOWN;
691 }
692 return ERROR_WIFI_BUSY;
693 }
694 g_wifiEvents[emptySlot] = event;
695 if (UnlockWifiEventLock() != WIFI_SUCCESS)
696 {
697 return ERROR_WIFI_UNKNOWN;
698 }
699
700 int ret=bk_event_register_cb(EVENT_MOD_WIFI, EVENT_ID_ALL, BkWifiEventCb, NULL);
701 return WIFI_SUCCESS;
702 }
703
UnRegisterWifiEvent(const WifiEvent * event)704 WifiErrorCode UnRegisterWifiEvent(const WifiEvent* event)
705 {
706 if (event == NULL)
707 {
708 return ERROR_WIFI_INVALID_ARGS;
709 }
710
711 if (LockWifiEventLock() != WIFI_SUCCESS)
712 {
713 return ERROR_WIFI_UNKNOWN;
714 }
715
716 for(int i=0; i<WIFI_MAX_EVENT_SIZE; i++)
717 {
718 if(g_wifiEvents[i] != event)
719 continue;
720
721 g_wifiEvents[i] = NULL;
722 if (UnlockWifiEventLock() != WIFI_SUCCESS)
723 {
724 return ERROR_WIFI_UNKNOWN;
725 }
726 return WIFI_SUCCESS;
727 }
728
729 if (UnlockWifiEventLock() != WIFI_SUCCESS)
730 {
731 return ERROR_WIFI_UNKNOWN;
732 }
733 return ERROR_WIFI_UNKNOWN;
734 }
735
GetDeviceMacAddress(unsigned char * result)736 WifiErrorCode GetDeviceMacAddress(unsigned char* result)
737 {
738 bk_wifi_sta_get_mac(result);
739 return WIFI_SUCCESS;
740 }
741
742
743 #define SSID_SCAN_TYPE 0
744 #define NORMAL_SCAN_TYPE 1
ScanTypeJudge(WifiScanParams * params,uint8_t * BkScanType)745 static WifiErrorCode ScanTypeJudge(WifiScanParams *params, uint8_t *BkScanType)
746 {
747 *BkScanType = NORMAL_SCAN_TYPE;
748
749 if((params->scanType == WIFI_FREQ_SCAN) && ((params->freqs < 2412 ) || (params->freqs > 2472)))
750 return ERROR_WIFI_UNKNOWN;
751
752 if( (params->scanType == WIFI_BSSID_SCAN) &&
753 ( (params->bssid[0] == 0)&& (params->bssid[1] == 0)&& (params->bssid[2] == 0)&& (params->bssid[3] == 0)&&
754 (params->bssid[4] == 0)&& (params->bssid[5] == 0)) )
755 return ERROR_WIFI_UNKNOWN;
756
757 if((params->scanType == WIFI_SSID_SCAN) &&(params->ssidLen == 0))
758 return ERROR_WIFI_UNKNOWN;
759
760 if(params->scanType == WIFI_SSID_SCAN)
761 *BkScanType = SSID_SCAN_TYPE;
762
763 return WIFI_SUCCESS;
764
765 }
766
767 //only support ssid advance scan now TODO
AdvanceScan(WifiScanParams * params)768 WifiErrorCode AdvanceScan(WifiScanParams *params)
769 {
770 uint8_t scan_type;
771 WifiErrorCode ret;
772 wifi_scan_config_t scan_config = {0};
773
774 if(params == NULL)
775 return ERROR_WIFI_UNKNOWN;
776
777 if (LockWifiEventLock() != WIFI_SUCCESS)
778 {
779 return ERROR_WIFI_UNKNOWN;
780 }
781 for (int i = 0; i < WIFI_MAX_EVENT_SIZE; i++)
782 {
783 if (g_wifiEvents[i] == NULL)
784 {
785 continue;
786 }
787 DispatchScanStateChangeEvent(NULL, g_wifiEvents[i]);
788 }
789 if (UnlockWifiEventLock() != WIFI_SUCCESS)
790 {
791 return ERROR_WIFI_UNKNOWN;
792 }
793
794 ret = ScanTypeJudge(params, &scan_type);
795 if(ret != WIFI_SUCCESS)
796 return ret;
797
798 if(scan_type== NORMAL_SCAN_TYPE)
799 {
800 ret=bk_wifi_scan_start(NULL);
801 }
802 else
803 {
804 memcpy(scan_config.ssid,params->ssid,WIFI_MAX_SSID_LEN);
805 ret=bk_wifi_scan_start(&scan_config);
806 }
807 if(ret == 0)
808 return WIFI_SUCCESS;
809 else
810 return ERROR_WIFI_UNKNOWN;
811
812 }
813
test_sta_connect(void)814 void test_sta_connect(void)
815 {
816 int result;
817 WifiDeviceConfig config={0};
818 strcpy(config.ssid, "BK-SZ-2.4G");
819 strcpy(config.preSharedKey,"sundray123");
820
821 AddDeviceConfig(&config, &result);
822 ConnectTo(result);
823 }
test_sta_scan(void)824 void test_sta_scan(void)
825 {
826 bk_printf("==%s 11===\r\n",__FUNCTION__);
827 #if 0
828 g_wifitest.OnWifiScanStateChanged = testOnWifiScanStateChangedHandler;
829 g_wifitest.OnWifiConnectionChanged = testOnWifiConnectionChangedHandler;
830 g_wifitest.OnHotspotStaJoin = NULL;
831 g_wifitest.OnHotspotStaLeave = NULL;
832 g_wifitest.OnHotspotStateChanged = NULL;
833 RegisterWifiEvent(&g_wifitest);
834 #endif
835 Scan();
836 #if 0
837 WifiScanParams * params;
838 AdvanceScan(WifiScanParams * params)
839 #endif
840 bk_printf("==%s 22===\r\n",__FUNCTION__);
841 }
842
843