1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include "cprecomp.h"
18#include "ratectrl.h"
19#include "../hal/hpreg.h"
20
21
22u8_t zgWpaRadiusOui[] = { 0x00, 0x50, 0xf2, 0x01 };
23u8_t zgWpaAesOui[] = { 0x00, 0x50, 0xf2, 0x04 };
24u8_t zgWpa2RadiusOui[] = { 0x00, 0x0f, 0xac, 0x01 };
25u8_t zgWpa2AesOui[] = { 0x00, 0x0f, 0xac, 0x04 };
26
27const u16_t zcCwTlb[16] = { 0, 1, 3, 7, 15, 31, 63, 127,
28 255, 511, 1023, 2047, 4095, 4095, 4095, 4095};
29
30void zfStaStartConnectCb(zdev_t* dev);
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49void zfStaPutApIntoBlockingList(zdev_t* dev, u8_t* bssid, u8_t weight)
50{
51 u16_t i, j;
52 zmw_get_wlan_dev(dev);
53 zmw_declare_for_critical_section();
54
55 if (weight > 0)
56 {
57 zmw_enter_critical_section(dev);
58
59 for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
60 {
61 for (j=0; j<6; j++)
62 {
63 if(wd->sta.blockingApList[i].addr[j]!= bssid[j])
64 {
65 break;
66 }
67 }
68
69 if(j==6)
70 {
71 break;
72 }
73 }
74
75 if (i == ZM_MAX_BLOCKING_AP_LIST_SIZE)
76 {
77 for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
78 {
79 if (wd->sta.blockingApList[i].weight == 0)
80 {
81 break;
82 }
83 }
84 }
85
86
87 if (i == ZM_MAX_BLOCKING_AP_LIST_SIZE)
88 {
89 i = bssid[5] & (ZM_MAX_BLOCKING_AP_LIST_SIZE-1);
90 }
91
92
93 for (j=0; j<6; j++)
94 {
95 wd->sta.blockingApList[i].addr[j] = bssid[j];
96 }
97
98 wd->sta.blockingApList[i].weight = weight;
99 zmw_leave_critical_section(dev);
100 }
101
102 return;
103}
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123u16_t zfStaIsApInBlockingList(zdev_t* dev, u8_t* bssid)
124{
125 u16_t i, j;
126 zmw_get_wlan_dev(dev);
127
128
129
130 for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
131 {
132 if (wd->sta.blockingApList[i].weight != 0)
133 {
134 for (j=0; j<6; j++)
135 {
136 if (wd->sta.blockingApList[i].addr[j] != bssid[j])
137 {
138 break;
139 }
140 }
141 if (j == 6)
142 {
143
144 return TRUE;
145 }
146 }
147 }
148
149 return FALSE;
150}
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169void zfStaRefreshBlockList(zdev_t* dev, u16_t flushFlag)
170{
171 u16_t i;
172 zmw_get_wlan_dev(dev);
173 zmw_declare_for_critical_section();
174
175 zmw_enter_critical_section(dev);
176 for (i=0; i<ZM_MAX_BLOCKING_AP_LIST_SIZE; i++)
177 {
178 if (wd->sta.blockingApList[i].weight != 0)
179 {
180 if (flushFlag != 0)
181 {
182 wd->sta.blockingApList[i].weight = 0;
183 }
184 else
185 {
186 wd->sta.blockingApList[i].weight--;
187 }
188 }
189 }
190 zmw_leave_critical_section(dev);
191 return;
192}
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212void zfStaConnectFail(zdev_t* dev, u16_t reason, u16_t* bssid, u8_t weight)
213{
214 zmw_get_wlan_dev(dev);
215
216
217 zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
218
219
220
221
222
223 if (wd->zfcbConnectNotify != NULL)
224 {
225 wd->zfcbConnectNotify(dev, reason, bssid);
226 }
227
228
229 zfStaPutApIntoBlockingList(dev, (u8_t *)bssid, weight);
230
231
232 if ( wd->sta.bAutoReconnect )
233 {
234 zm_debug_msg0("Start internal scan...");
235 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
236 zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
237 }
238}
239
240u8_t zfiWlanIBSSGetPeerStationsCount(zdev_t* dev)
241{
242 zmw_get_wlan_dev(dev);
243
244 return wd->sta.oppositeCount;
245}
246
247u8_t zfiWlanIBSSIteratePeerStations(zdev_t* dev, u8_t numToIterate, zfpIBSSIteratePeerStationCb callback, void *ctx)
248{
249 u8_t oppositeCount;
250 u8_t i;
251 u8_t index = 0;
252
253 zmw_get_wlan_dev(dev);
254
255 zmw_declare_for_critical_section();
256
257 zmw_enter_critical_section(dev);
258
259 oppositeCount = wd->sta.oppositeCount;
260 if ( oppositeCount > numToIterate )
261 {
262 oppositeCount = numToIterate;
263 }
264
265 for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
266 {
267 if ( oppositeCount == 0 )
268 {
269 break;
270 }
271
272 if ( wd->sta.oppositeInfo[i].valid == 0 )
273 {
274 continue;
275 }
276
277 callback(dev, &wd->sta.oppositeInfo[i], ctx, index++);
278 oppositeCount--;
279
280 }
281
282 zmw_leave_critical_section(dev);
283
284 return index;
285}
286
287
288s8_t zfStaFindFreeOpposite(zdev_t* dev, u16_t *sa, int *pFoundIdx)
289{
290 int oppositeCount;
291 int i;
292
293 zmw_get_wlan_dev(dev);
294
295 oppositeCount = wd->sta.oppositeCount;
296
297 for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
298 {
299 if ( oppositeCount == 0 )
300 {
301 break;
302 }
303
304 if ( wd->sta.oppositeInfo[i].valid == 0 )
305 {
306 continue;
307 }
308
309 oppositeCount--;
310 if ( zfMemoryIsEqual((u8_t*) sa, wd->sta.oppositeInfo[i].macAddr, 6) )
311 {
312
313 wd->sta.oppositeInfo[i].aliveCounter = ZM_IBSS_PEER_ALIVE_COUNTER;
314
315
316 return 1;
317 }
318 }
319
320
321 if ( wd->sta.oppositeCount == ZM_MAX_OPPOSITE_COUNT )
322 {
323 return -1;
324 }
325
326
327 for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
328 {
329 if ( wd->sta.oppositeInfo[i].valid == 0 )
330 {
331 break;
332 }
333 }
334
335 *pFoundIdx = i;
336 return 0;
337}
338
339s8_t zfStaFindOppositeByMACAddr(zdev_t* dev, u16_t *sa, u8_t *pFoundIdx)
340{
341 u32_t oppositeCount;
342 u32_t i;
343
344 zmw_get_wlan_dev(dev);
345
346 oppositeCount = wd->sta.oppositeCount;
347
348 for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
349 {
350 if ( oppositeCount == 0 )
351 {
352 break;
353 }
354
355 if ( wd->sta.oppositeInfo[i].valid == 0 )
356 {
357 continue;
358 }
359
360 oppositeCount--;
361 if ( zfMemoryIsEqual((u8_t*) sa, wd->sta.oppositeInfo[i].macAddr, 6) )
362 {
363 *pFoundIdx = (u8_t)i;
364
365 return 0;
366 }
367 }
368
369 *pFoundIdx = 0;
370 return 1;
371}
372
373static void zfStaInitCommonOppositeInfo(zdev_t* dev, int i)
374{
375 zmw_get_wlan_dev(dev);
376
377
378 wd->sta.oppositeInfo[i].valid = 1;
379 wd->sta.oppositeInfo[i].aliveCounter = ZM_IBSS_PEER_ALIVE_COUNTER;
380 wd->sta.oppositeCount++;
381
382#ifdef ZM_ENABLE_IBSS_WPA2PSK
383
384 wd->sta.oppositeInfo[i].camIdx = 0xff;
385 wd->sta.oppositeInfo[i].pkInstalled = 0;
386 wd->sta.oppositeInfo[i].wpaState = ZM_STA_WPA_STATE_INIT ;
387#endif
388}
389
390int zfStaSetOppositeInfoFromBSSInfo(zdev_t* dev, struct zsBssInfo* pBssInfo)
391{
392 int i;
393 u8_t* dst;
394 u16_t sa[3];
395 int res;
396 u32_t oneTxStreamCap;
397
398 zmw_get_wlan_dev(dev);
399
400 zfMemoryCopy((u8_t*) sa, pBssInfo->macaddr, 6);
401
402 res = zfStaFindFreeOpposite(dev, sa, &i);
403 if ( res != 0 )
404 {
405 goto zlReturn;
406 }
407
408 dst = wd->sta.oppositeInfo[i].macAddr;
409 zfMemoryCopy(dst, (u8_t *)sa, 6);
410
411 oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
412
413 if (pBssInfo->extSupportedRates[1] != 0)
414 {
415
416 if (pBssInfo->frequency < 3000)
417 {
418
419 if (pBssInfo->EnableHT == 1)
420 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, pBssInfo->SG40);
421 else
422 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 1, pBssInfo->SG40);
423 }
424 else
425 {
426
427 if (pBssInfo->EnableHT == 1)
428 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, pBssInfo->SG40);
429 else
430 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, pBssInfo->SG40);
431 }
432 }
433 else
434 {
435
436 if (pBssInfo->frequency < 3000)
437 {
438
439 if (pBssInfo->EnableHT == 1)
440 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, pBssInfo->SG40);
441 else
442 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 0, 1, pBssInfo->SG40);
443 }
444 else
445 {
446
447 if (pBssInfo->EnableHT == 1)
448 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, pBssInfo->SG40);
449 else
450 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, pBssInfo->SG40);
451 }
452 }
453
454
455 zfStaInitCommonOppositeInfo(dev, i);
456zlReturn:
457 return 0;
458}
459
460int zfStaSetOppositeInfoFromRxBuf(zdev_t* dev, zbuf_t* buf)
461{
462 int i;
463 u8_t* dst;
464 u16_t sa[3];
465 int res = 0;
466 u16_t offset;
467 u8_t bSupportExtRate;
468 u32_t rtsctsRate = 0xffffffff;
469 u32_t oneTxStreamCap;
470
471 zmw_get_wlan_dev(dev);
472 zmw_declare_for_critical_section();
473
474 sa[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET);
475 sa[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+2);
476 sa[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+4);
477
478 zmw_enter_critical_section(dev);
479
480 res = zfStaFindFreeOpposite(dev, sa, &i);
481 if ( res != 0 )
482 {
483 goto zlReturn;
484 }
485
486 dst = wd->sta.oppositeInfo[i].macAddr;
487 zfCopyFromRxBuffer(dev, buf, dst, ZM_WLAN_HEADER_A2_OFFSET, 6);
488
489 if ( (wd->sta.currentFrequency < 3000) && !(wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
490 {
491 bSupportExtRate = 0;
492 } else {
493 bSupportExtRate = 1;
494 }
495
496 if ( (bSupportExtRate == 1)
497 && (wd->sta.currentFrequency < 3000)
498 && (wd->wlanMode == ZM_MODE_IBSS)
499 && (wd->wfc.bIbssGMode == 0) )
500 {
501 bSupportExtRate = 0;
502 }
503
504 wd->sta.connection_11b = 0;
505 oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
506
507 if ( ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_RATE)) != 0xffff)
508 && (bSupportExtRate == 1) )
509 {
510
511 if (wd->sta.currentFrequency < 3000)
512 {
513
514 if (wd->sta.EnableHT == 1)
515 {
516
517 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, wd->sta.SG40);
518 }
519 else
520 {
521
522 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 1, wd->sta.SG40);
523 }
524 rtsctsRate = 0x00001bb;
525 }
526 else
527 {
528
529 if (wd->sta.EnableHT == 1)
530 {
531
532 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, wd->sta.SG40);
533 }
534 else
535 {
536
537 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, wd->sta.SG40);
538 }
539 rtsctsRate = 0x10b01bb;
540 }
541 }
542 else
543 {
544
545 if (wd->sta.currentFrequency < 3000)
546 {
547
548 if (wd->sta.EnableHT == 1)
549 {
550
551 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 1, wd->sta.SG40);
552 rtsctsRate = 0x00001bb;
553 }
554 else
555 {
556
557 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 0, 1, wd->sta.SG40);
558 rtsctsRate = 0x0;
559 wd->sta.connection_11b = 1;
560 }
561 }
562 else
563 {
564
565 if (wd->sta.EnableHT == 1)
566 {
567
568 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, (oneTxStreamCap!=0)?3:2, 0, wd->sta.SG40);
569 }
570 else
571 {
572
573 zfRateCtrlInitCell(dev, &wd->sta.oppositeInfo[i].rcCell, 1, 0, wd->sta.SG40);
574 }
575 rtsctsRate = 0x10b01bb;
576 }
577 }
578
579 zfStaInitCommonOppositeInfo(dev, i);
580
581zlReturn:
582 zmw_leave_critical_section(dev);
583
584 if (rtsctsRate != 0xffffffff)
585 {
586 zfHpSetRTSCTSRate(dev, rtsctsRate);
587 }
588 return res;
589}
590
591void zfStaProtErpMonitor(zdev_t* dev, zbuf_t* buf)
592{
593 u16_t offset;
594 u8_t erp;
595 u8_t bssid[6];
596
597 zmw_get_wlan_dev(dev);
598
599 if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&&(zfStaIsConnected(dev)) )
600 {
601 ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, bssid);
602
603 if (zfRxBufferEqualToStr(dev, buf, bssid, ZM_WLAN_HEADER_A2_OFFSET, 6))
604 {
605 if ( (offset=zfFindElement(dev, buf, ZM_WLAN_EID_ERP)) != 0xffff )
606 {
607 erp = zmw_rx_buf_readb(dev, buf, offset+2);
608
609 if ( erp & ZM_BIT_1 )
610 {
611
612 if (wd->sta.bProtectionMode == FALSE)
613 {
614 wd->sta.bProtectionMode = TRUE;
615 zfHpSetSlotTime(dev, 0);
616 }
617 }
618 else
619 {
620
621 if (wd->sta.bProtectionMode == TRUE)
622 {
623 wd->sta.bProtectionMode = FALSE;
624 zfHpSetSlotTime(dev, 1);
625 }
626 }
627 }
628 }
629
630
631 if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_HT_CAPABILITY)) != 0xffff)
632 {}
633 else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTCAPABILITY)) != 0xffff)
634 {}
635 else
636 {wd->sta.NonNAPcount++;}
637 }
638}
639
640void zfStaUpdateWmeParameter(zdev_t* dev, zbuf_t* buf)
641{
642 u16_t tmp;
643 u16_t aifs[5];
644 u16_t cwmin[5];
645 u16_t cwmax[5];
646 u16_t txop[5];
647 u8_t acm;
648 u8_t ac;
649 u16_t len;
650 u16_t i;
651 u16_t offset;
652 u8_t rxWmeParameterSetCount;
653
654 zmw_get_wlan_dev(dev);
655
656
657
658 if (wd->sta.wmeConnected != 0)
659 {
660
661 if ((offset = zfFindWifiElement(dev, buf, 2, 1)) != 0xffff)
662 {
663 if ((len = zmw_rx_buf_readb(dev, buf, offset+1)) >= 7)
664 {
665 rxWmeParameterSetCount=zmw_rx_buf_readb(dev, buf, offset+8);
666 if (rxWmeParameterSetCount != wd->sta.wmeParameterSetCount)
667 {
668 zm_msg0_mm(ZM_LV_0, "wmeParameterSetCount changed!");
669 wd->sta.wmeParameterSetCount = rxWmeParameterSetCount;
670
671 acm = 0xf;
672 for (i=0; i<4; i++)
673 {
674 if (len >= (8+(i*4)+4))
675 {
676 tmp=zmw_rx_buf_readb(dev, buf, offset+10+i*4);
677 ac = (tmp >> 5) & 0x3;
678 if ((tmp & 0x10) == 0)
679 {
680 acm &= (~(1<<ac));
681 }
682 aifs[ac] = ((tmp & 0xf) * 9) + 10;
683 tmp=zmw_rx_buf_readb(dev, buf, offset+11+i*4);
684
685 cwmin[ac] = zcCwTlb[(tmp & 0xf)];
686 cwmax[ac] = zcCwTlb[(tmp >> 4)];
687 txop[ac]=zmw_rx_buf_readh(dev, buf,
688 offset+12+i*4);
689 }
690 }
691
692 if ((acm & 0x4) != 0)
693 {
694 cwmin[2] = cwmin[0];
695 cwmax[2] = cwmax[0];
696 aifs[2] = aifs[0];
697 txop[2] = txop[0];
698 }
699 if ((acm & 0x8) != 0)
700 {
701 cwmin[3] = cwmin[2];
702 cwmax[3] = cwmax[2];
703 aifs[3] = aifs[2];
704 txop[3] = txop[2];
705 }
706 cwmin[4] = 3;
707 cwmax[4] = 7;
708 aifs[4] = 28;
709
710 if ((cwmin[2]+aifs[2]) > ((cwmin[0]+aifs[0])+1))
711 {
712 wd->sta.ac0PriorityHigherThanAc2 = 1;
713 }
714 else
715 {
716 wd->sta.ac0PriorityHigherThanAc2 = 0;
717 }
718 zfHpUpdateQosParameter(dev, cwmin, cwmax, aifs, txop);
719 }
720 }
721 }
722 }
723}
724
725void zfStaUpdateDot11HDFS(zdev_t* dev, zbuf_t* buf)
726{
727
728 u16_t offset;
729
730 zmw_get_wlan_dev(dev);
731
732
733
734
735
736
737
738
739
740
741
742
743
744 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_CHANNEL_SWITCH_ANNOUNCE)) == 0xffff )
745 {
746
747 return;
748 }
749 else if ( zmw_rx_buf_readb(dev, buf, offset+1) == 0x3 )
750 {
751 zm_debug_msg0("EID(Channel Switch Announcement) found");
752
753
754
755
756
757
758 if (zmw_rx_buf_readb(dev, buf, offset+2) == 0x1 )
759 {
760
761
762 if (wd->sta.DFSDisableTx != TRUE)
763 {
764
765
766 wd->sta.DFSDisableTx = TRUE;
767
768 zfHpStartRecv(dev);
769 }
770
771
772
773
774 }
775
776 if (zmw_rx_buf_readb(dev, buf, offset+4) <= 0x2 )
777 {
778
779
780
781
782
783
784
785 zfHpDeleteAllowChannel(dev, wd->sta.currentFrequency);
786 wd->frequency = zfChNumToFreq(dev, zmw_rx_buf_readb(dev, buf, offset+3), 0);
787
788 zm_debug_msg1("CWY - jump to frequency = ", wd->frequency);
789 zfCoreSetFrequency(dev, wd->frequency);
790 wd->sta.DFSDisableTx = FALSE;
791
792 if (zfStaIsConnected(dev))
793 {
794 wd->sta.rxBeaconCount = 1 << 6;
795 }
796
797
798
799
800
801
802
803
804
805
806
807
808 }
809 }
810
811}
812
813void zfStaUpdateDot11HTPC(zdev_t* dev, zbuf_t* buf)
814{
815}
816
817
818void zfStaIbssPSCheckState(zdev_t* dev, zbuf_t* buf)
819{
820 u8_t i, frameCtrl;
821
822 zmw_get_wlan_dev(dev);
823
824 if ( !zfStaIsConnected(dev) )
825 {
826 return;
827 }
828
829 if ( wd->wlanMode != ZM_MODE_IBSS )
830 {
831 return ;
832 }
833
834
835 if ( !zfRxBufferEqualToStr(dev, buf, (u8_t*) wd->sta.bssid,
836 ZM_WLAN_HEADER_A3_OFFSET, 6) )
837 {
838 return;
839 }
840
841 frameCtrl = zmw_rx_buf_readb(dev, buf, 1);
842
843
844 if ( frameCtrl & ZM_BIT_4 )
845 {
846 for(i=1; i<ZM_MAX_PS_STA; i++)
847 {
848 if ( !wd->sta.staPSList.entity[i].bUsed )
849 {
850 continue;
851 }
852
853
854 if ( zfRxBufferEqualToStr(dev, buf,
855 wd->sta.staPSList.entity[i].macAddr,
856 ZM_WLAN_HEADER_A2_OFFSET, 6) )
857 {
858 return;
859 }
860 }
861
862 for(i=1; i<ZM_MAX_PS_STA; i++)
863 {
864 if ( !wd->sta.staPSList.entity[i].bUsed )
865 {
866 wd->sta.staPSList.entity[i].bUsed = TRUE;
867 wd->sta.staPSList.entity[i].bDataQueued = FALSE;
868 break;
869 }
870 }
871
872 if ( i == ZM_MAX_PS_STA )
873 {
874
875 return;
876 }
877
878 zfCopyFromRxBuffer(dev, buf, wd->sta.staPSList.entity[i].macAddr,
879 ZM_WLAN_HEADER_A2_OFFSET, 6);
880
881 if ( wd->sta.staPSList.count == 0 )
882 {
883
884
885 }
886
887 wd->sta.staPSList.count++;
888 }
889 else if ( wd->sta.staPSList.count )
890 {
891 for(i=1; i<ZM_MAX_PS_STA; i++)
892 {
893 if ( wd->sta.staPSList.entity[i].bUsed )
894 {
895 if ( zfRxBufferEqualToStr(dev, buf,
896 wd->sta.staPSList.entity[i].macAddr,
897 ZM_WLAN_HEADER_A2_OFFSET, 6) )
898 {
899 wd->sta.staPSList.entity[i].bUsed = FALSE;
900 wd->sta.staPSList.count--;
901
902 if ( wd->sta.staPSList.entity[i].bDataQueued )
903 {
904
905 }
906 }
907 }
908 }
909
910 if ( wd->sta.staPSList.count == 0 )
911 {
912
913
914 }
915
916 }
917}
918
919
920u8_t zfStaIbssPSQueueData(zdev_t* dev, zbuf_t* buf)
921{
922 u8_t i;
923 u16_t da[3];
924
925 zmw_get_wlan_dev(dev);
926
927 if ( !zfStaIsConnected(dev) )
928 {
929 return 0;
930 }
931
932 if ( wd->wlanMode != ZM_MODE_IBSS )
933 {
934 return 0;
935 }
936
937 if ( wd->sta.staPSList.count == 0 && wd->sta.powerSaveMode <= ZM_STA_PS_NONE )
938 {
939 return 0;
940 }
941
942
943#ifdef ZM_ENABLE_NATIVE_WIFI
944 da[0] = zmw_tx_buf_readh(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
945 da[1] = zmw_tx_buf_readh(dev, buf, ZM_WLAN_HEADER_A1_OFFSET + 2);
946 da[2] = zmw_tx_buf_readh(dev, buf, ZM_WLAN_HEADER_A1_OFFSET + 4);
947#else
948 da[0] = zmw_tx_buf_readh(dev, buf, 0);
949 da[1] = zmw_tx_buf_readh(dev, buf, 2);
950 da[2] = zmw_tx_buf_readh(dev, buf, 4);
951#endif
952
953 if ( ZM_IS_MULTICAST_OR_BROADCAST(da) )
954 {
955 wd->sta.staPSList.entity[0].bDataQueued = TRUE;
956 wd->sta.ibssPSDataQueue[wd->sta.ibssPSDataCount++] = buf;
957 return 1;
958 }
959
960
961
962 for(i=1; i<ZM_MAX_PS_STA; i++)
963 {
964 if ( zfMemoryIsEqual(wd->sta.staPSList.entity[i].macAddr,
965 (u8_t*) da, 6) )
966 {
967 wd->sta.staPSList.entity[i].bDataQueued = TRUE;
968 wd->sta.ibssPSDataQueue[wd->sta.ibssPSDataCount++] = buf;
969
970 return 1;
971 }
972 }
973
974#if 0
975 if ( wd->sta.powerSaveMode > ZM_STA_PS_NONE )
976 {
977 wd->sta.staPSDataQueue[wd->sta.staPSDataCount++] = buf;
978
979 return 1;
980 }
981#endif
982
983 return 0;
984}
985
986
987void zfStaIbssPSSend(zdev_t* dev)
988{
989 u8_t i;
990 u16_t bcastAddr[3] = {0xffff, 0xffff, 0xffff};
991
992 zmw_get_wlan_dev(dev);
993
994 if ( !zfStaIsConnected(dev) )
995 {
996 return ;
997 }
998
999 if ( wd->wlanMode != ZM_MODE_IBSS )
1000 {
1001 return ;
1002 }
1003
1004 for(i=0; i<ZM_MAX_PS_STA; i++)
1005 {
1006 if ( wd->sta.staPSList.entity[i].bDataQueued )
1007 {
1008 if ( i == 0 )
1009 {
1010 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ATIM,
1011 bcastAddr,
1012 0, 0, 0);
1013 }
1014 else if ( wd->sta.staPSList.entity[i].bUsed )
1015 {
1016
1017 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ATIM,
1018 (u16_t*) wd->sta.staPSList.entity[i].macAddr,
1019 0, 0, 0);
1020 }
1021
1022 wd->sta.staPSList.entity[i].bDataQueued = FALSE;
1023 }
1024 }
1025
1026 for(i=0; i<wd->sta.ibssPSDataCount; i++)
1027 {
1028 zfTxSendEth(dev, wd->sta.ibssPSDataQueue[i], 0,
1029 ZM_EXTERNAL_ALLOC_BUF, 0);
1030 }
1031
1032 wd->sta.ibssPrevPSDataCount = wd->sta.ibssPSDataCount;
1033 wd->sta.ibssPSDataCount = 0;
1034}
1035
1036
1037void zfStaReconnect(zdev_t* dev)
1038{
1039 zmw_get_wlan_dev(dev);
1040 zmw_declare_for_critical_section();
1041
1042 if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE &&
1043 wd->wlanMode != ZM_MODE_IBSS )
1044 {
1045 return;
1046 }
1047
1048 if ( (zfStaIsConnected(dev))||(zfStaIsConnecting(dev)) )
1049 {
1050 return;
1051 }
1052
1053 if ( wd->sta.bChannelScan )
1054 {
1055 return;
1056 }
1057
1058
1059 if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && (wd->ws.ssidLen == 0))
1060 {
1061 zm_debug_msg0("zfStaReconnect: NOT Support!! Set SSID to any BSS");
1062
1063 zmw_enter_critical_section(dev);
1064 wd->sta.ssid[0] = 0;
1065 wd->sta.ssidLen = 0;
1066 zmw_leave_critical_section(dev);
1067 }
1068
1069
1070 zfFlushVtxq(dev);
1071 zfWlanEnable(dev);
1072 zfScanMgrScanAck(dev);
1073}
1074
1075void zfStaTimer100ms(zdev_t* dev)
1076{
1077 zmw_get_wlan_dev(dev);
1078
1079 if ( (wd->tick % 10) == 0 )
1080 {
1081 zfPushVtxq(dev);
1082
1083 }
1084}
1085
1086
1087void zfStaCheckRxBeacon(zdev_t* dev)
1088{
1089 zmw_get_wlan_dev(dev);
1090
1091 if (( wd->wlanMode == ZM_MODE_INFRASTRUCTURE ) && (zfStaIsConnected(dev)))
1092 {
1093 if (wd->beaconInterval == 0)
1094 {
1095 wd->beaconInterval = 100;
1096 }
1097 if ( (wd->tick % ((wd->beaconInterval * 10) / ZM_MS_PER_TICK)) == 0 )
1098 {
1099
1100 if (wd->sta.rxBeaconCount == 0)
1101 {
1102 if (wd->sta.beaconMissState == 1)
1103 {
1104
1105 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
1106
1107 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_BEACON_MISS,
1108 wd->sta.bssid, 0);
1109 }
1110 else
1111 {
1112 wd->sta.beaconMissState = 1;
1113
1114 zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40,
1115 wd->ExtOffset, NULL, 1);
1116 }
1117 }
1118 else
1119 {
1120 wd->sta.beaconMissState = 0;
1121 }
1122 wd->sta.rxBeaconCount = 0;
1123 }
1124 }
1125}
1126
1127
1128
1129void zfStaCheckConnectTimeout(zdev_t* dev)
1130{
1131 zmw_get_wlan_dev(dev);
1132 zmw_declare_for_critical_section();
1133
1134 if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE )
1135 {
1136 return;
1137 }
1138
1139 if ( !zfStaIsConnecting(dev) )
1140 {
1141 return;
1142 }
1143
1144 zmw_enter_critical_section(dev);
1145 if ( (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_OPEN)||
1146 (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_1)||
1147 (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_2)||
1148 (wd->sta.connectState == ZM_STA_CONN_STATE_ASSOCIATE) )
1149 {
1150 if ( (wd->tick - wd->sta.connectTimer) > ZM_INTERVAL_CONNECT_TIMEOUT )
1151 {
1152 if ( wd->sta.connectByReasso )
1153 {
1154 wd->sta.failCntOfReasso++;
1155 if ( wd->sta.failCntOfReasso > 2 )
1156 {
1157 wd->sta.connectByReasso = FALSE;
1158 }
1159 }
1160
1161 wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
1162 zm_debug_msg1("connect timeout, state = ", wd->sta.connectState);
1163
1164 goto failed;
1165 }
1166 }
1167
1168 zmw_leave_critical_section(dev);
1169 return;
1170
1171failed:
1172 zmw_leave_critical_section(dev);
1173 if(wd->sta.authMode == ZM_AUTH_MODE_AUTO)
1174 {
1175 wd->sta.connectTimeoutCount++;
1176 }
1177 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_TIMEOUT, wd->sta.bssid, 2);
1178 return;
1179}
1180
1181void zfMmStaTimeTick(zdev_t* dev)
1182{
1183 zmw_get_wlan_dev(dev);
1184
1185
1186 if (wd->wlanMode != ZM_MODE_AP && !wd->swSniffer)
1187 {
1188 if ( wd->tick & 1 )
1189 {
1190 zfTimerCheckAndHandle(dev);
1191 }
1192
1193 zfStaCheckRxBeacon(dev);
1194 zfStaTimer100ms(dev);
1195 zfStaCheckConnectTimeout(dev);
1196 zfPowerSavingMgrMain(dev);
1197 }
1198
1199#ifdef ZM_ENABLE_AGGREGATION
1200
1201
1202
1203 zfAggScanAndClear(dev, wd->tick);
1204#endif
1205}
1206
1207void zfStaSendBeacon(zdev_t* dev)
1208{
1209 zbuf_t* buf;
1210 u16_t offset, seq;
1211
1212 zmw_get_wlan_dev(dev);
1213
1214 zmw_declare_for_critical_section();
1215
1216
1217
1218
1219 if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
1220 {
1221 zm_debug_msg0("Allocate beacon buffer failed");
1222 return;
1223 }
1224
1225 offset = 0;
1226
1227
1228 zmw_tx_buf_writeh(dev, buf, offset, 0x0080);
1229 offset+=2;
1230
1231 zmw_tx_buf_writeh(dev, buf, offset, 0x0000);
1232 offset+=2;
1233
1234 zmw_tx_buf_writeh(dev, buf, offset, 0xffff);
1235 offset+=2;
1236 zmw_tx_buf_writeh(dev, buf, offset, 0xffff);
1237 offset+=2;
1238 zmw_tx_buf_writeh(dev, buf, offset, 0xffff);
1239 offset+=2;
1240
1241 zmw_tx_buf_writeh(dev, buf, offset, wd->macAddr[0]);
1242 offset+=2;
1243 zmw_tx_buf_writeh(dev, buf, offset, wd->macAddr[1]);
1244 offset+=2;
1245 zmw_tx_buf_writeh(dev, buf, offset, wd->macAddr[2]);
1246 offset+=2;
1247
1248 zmw_tx_buf_writeh(dev, buf, offset, wd->sta.bssid[0]);
1249 offset+=2;
1250 zmw_tx_buf_writeh(dev, buf, offset, wd->sta.bssid[1]);
1251 offset+=2;
1252 zmw_tx_buf_writeh(dev, buf, offset, wd->sta.bssid[2]);
1253 offset+=2;
1254
1255
1256 zmw_enter_critical_section(dev);
1257 seq = ((wd->mmseq++)<<4);
1258 zmw_leave_critical_section(dev);
1259 zmw_tx_buf_writeh(dev, buf, offset, seq);
1260 offset+=2;
1261
1262
1263 offset+=8;
1264
1265
1266 zmw_tx_buf_writeh(dev, buf, offset, wd->beaconInterval);
1267 offset+=2;
1268
1269
1270 zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.capability[0]);
1271 zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.capability[1]);
1272
1273
1274 offset = zfStaAddIeSsid(dev, buf, offset);
1275
1276 if(wd->frequency <= ZM_CH_G_14)
1277 {
1278
1279
1280 offset = zfMmAddIeSupportRate(dev, buf, offset,
1281 ZM_WLAN_EID_SUPPORT_RATE, ZM_RATE_SET_CCK);
1282
1283
1284 offset = zfMmAddIeDs(dev, buf, offset);
1285
1286 offset = zfStaAddIeIbss(dev, buf, offset);
1287
1288 if( wd->wfc.bIbssGMode
1289 && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
1290 {
1291
1292 wd->erpElement = 0;
1293 offset = zfMmAddIeErp(dev, buf, offset);
1294 }
1295
1296
1297
1298 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
1299 {
1300 offset = zfwStaAddIeWpaRsn(dev, buf, offset, ZM_WLAN_FRAME_TYPE_AUTH);
1301 }
1302
1303 if( wd->wfc.bIbssGMode
1304 && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
1305 {
1306
1307
1308 offset = zfMmAddIeSupportRate(dev, buf, offset,
1309 ZM_WLAN_EID_EXTENDED_RATE, ZM_RATE_SET_OFDM);
1310 }
1311 }
1312 else
1313 {
1314
1315 offset = zfMmAddIeSupportRate(dev, buf, offset,
1316 ZM_WLAN_EID_SUPPORT_RATE, ZM_RATE_SET_OFDM);
1317
1318
1319 offset = zfMmAddIeDs(dev, buf, offset);
1320
1321 offset = zfStaAddIeIbss(dev, buf, offset);
1322
1323
1324
1325 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
1326 {
1327 offset = zfwStaAddIeWpaRsn(dev, buf, offset, ZM_WLAN_FRAME_TYPE_AUTH);
1328 }
1329 }
1330
1331 if ( wd->wlanMode != ZM_MODE_IBSS )
1332 {
1333
1334
1335 offset = zfMmAddHTCapability(dev, buf, offset);
1336
1337
1338 offset = zfMmAddExtendedHTCapability(dev, buf, offset);
1339 }
1340
1341 if ( wd->sta.ibssAdditionalIESize )
1342 offset = zfStaAddIbssAdditionalIE(dev, buf, offset);
1343
1344
1345
1346 zfHpSendBeacon(dev, buf, offset);
1347
1348
1349
1350}
1351
1352void zfStaSignalStatistic(zdev_t* dev, u8_t SignalStrength, u8_t SignalQuality)
1353{
1354 zmw_get_wlan_dev(dev);
1355
1356
1357 wd->SignalStrength = (wd->SignalStrength * 7 + SignalStrength * 3)/10;
1358 wd->SignalQuality = (wd->SignalQuality * 7 + SignalQuality * 3)/10;
1359
1360}
1361
1362struct zsBssInfo* zfStaFindBssInfo(zdev_t* dev, zbuf_t* buf, struct zsWlanProbeRspFrameHeader *pProbeRspHeader)
1363{
1364 u8_t i;
1365 u8_t j;
1366 u8_t k;
1367 u8_t isMatched, length, channel;
1368 u16_t offset, frequency;
1369 struct zsBssInfo* pBssInfo;
1370
1371 zmw_get_wlan_dev(dev);
1372
1373 if ((pBssInfo = wd->sta.bssList.head) == NULL)
1374 {
1375 return NULL;
1376 }
1377
1378 for( i=0; i<wd->sta.bssList.bssCount; i++ )
1379 {
1380
1381
1382
1383 for( j=0; j<6; j++ )
1384 {
1385 if ( pBssInfo->bssid[j] != pProbeRspHeader->bssid[j] )
1386 {
1387 break;
1388 }
1389 }
1390
1391
1392 if (j == 6)
1393 {
1394 if (pProbeRspHeader->ssid[1] <= 32)
1395 {
1396
1397 isMatched = 1;
1398 if((pProbeRspHeader->ssid[1] != 0) && (pBssInfo->ssid[1] != 0))
1399 {
1400 for( k=1; k<pProbeRspHeader->ssid[1] + 1; k++ )
1401 {
1402 if ( pBssInfo->ssid[k] != pProbeRspHeader->ssid[k] )
1403 {
1404 isMatched = 0;
1405 break;
1406 }
1407 }
1408 }
1409 }
1410 else
1411 {
1412 isMatched = 0;
1413 }
1414 }
1415 else
1416 {
1417 isMatched = 0;
1418 }
1419
1420
1421
1422 if (isMatched) {
1423 if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_DS)) != 0xffff) {
1424 if ((length = zmw_rx_buf_readb(dev, buf, offset+1)) == 1) {
1425 channel = zmw_rx_buf_readb(dev, buf, offset+2);
1426 if (zfHpIsAllowedChannel(dev, zfChNumToFreq(dev, channel, 0)) == 0) {
1427 frequency = 0;
1428 } else {
1429 frequency = zfChNumToFreq(dev, channel, 0);;
1430 }
1431 } else {
1432 frequency = 0;
1433 }
1434 } else {
1435 frequency = wd->sta.currentFrequency;
1436 }
1437
1438 if (frequency != 0) {
1439 if ( ((frequency > 3000) && (pBssInfo->frequency > 3000))
1440 || ((frequency < 3000) && (pBssInfo->frequency < 3000)) ) {
1441
1442 break;
1443 }
1444 }
1445 }
1446
1447 pBssInfo = pBssInfo->next;
1448 }
1449
1450 if ( i == wd->sta.bssList.bssCount )
1451 {
1452 pBssInfo = NULL;
1453 }
1454
1455 return pBssInfo;
1456}
1457
1458u8_t zfStaInitBssInfo(zdev_t* dev, zbuf_t* buf,
1459 struct zsWlanProbeRspFrameHeader *pProbeRspHeader,
1460 struct zsBssInfo* pBssInfo, struct zsAdditionInfo* AddInfo, u8_t type)
1461{
1462 u8_t length, channel, is5G;
1463 u16_t i, offset;
1464 u8_t apQosInfo;
1465 u16_t eachIElength = 0;
1466 u16_t accumulateLen = 0;
1467
1468 zmw_get_wlan_dev(dev);
1469
1470 if ((type == 1) && ((pBssInfo->flag & ZM_BSS_INFO_VALID_BIT) != 0))
1471 {
1472 goto zlUpdateRssi;
1473 }
1474
1475
1476 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_SSID)) == 0xffff )
1477 {
1478 zm_debug_msg0("EID(SSID) not found");
1479 goto zlError;
1480 }
1481
1482 length = zmw_rx_buf_readb(dev, buf, offset+1);
1483
1484 {
1485 u8_t Show_Flag = 0;
1486 zfwGetShowZeroLengthSSID(dev, &Show_Flag);
1487
1488 if(Show_Flag)
1489 {
1490 if (length > ZM_MAX_SSID_LENGTH )
1491 {
1492 zm_debug_msg0("EID(SSID) is invalid");
1493 goto zlError;
1494 }
1495 }
1496 else
1497 {
1498 if ( length == 0 || length > ZM_MAX_SSID_LENGTH )
1499 {
1500 zm_debug_msg0("EID(SSID) is invalid");
1501 goto zlError;
1502 }
1503
1504 }
1505 }
1506 zfCopyFromRxBuffer(dev, buf, pBssInfo->ssid, offset, length+2);
1507
1508
1509 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_DS)) != 0xffff )
1510 {
1511 length = zmw_rx_buf_readb(dev, buf, offset+1);
1512 if ( length != 1 )
1513 {
1514 zm_msg0_mm(ZM_LV_0, "Abnormal DS Param Set IE");
1515 goto zlError;
1516 }
1517 channel = zmw_rx_buf_readb(dev, buf, offset+2);
1518
1519 if (zfHpIsAllowedChannel(dev, zfChNumToFreq(dev, channel, 0)) == 0)
1520 {
1521 goto zlError2;
1522 }
1523
1524 pBssInfo->frequency = zfChNumToFreq(dev, channel, 0);
1525 pBssInfo->channel = channel;
1526
1527
1528 }
1529 else
1530 {
1531
1532 pBssInfo->frequency = wd->sta.currentFrequency;
1533 pBssInfo->channel = zfChFreqToNum(wd->sta.currentFrequency, &is5G);
1534 }
1535
1536
1537 pBssInfo->securityType = ZM_SECURITY_TYPE_NONE;
1538
1539
1540 for( i=0; i<6; i++ )
1541 {
1542 pBssInfo->macaddr[i] = pProbeRspHeader->sa[i];
1543 }
1544
1545
1546 for( i=0; i<6; i++ )
1547 {
1548 pBssInfo->bssid[i] = pProbeRspHeader->bssid[i];
1549 }
1550
1551
1552 for( i=0; i<8; i++ )
1553 {
1554 pBssInfo->timeStamp[i] = pProbeRspHeader->timeStamp[i];
1555 }
1556
1557
1558 pBssInfo->beaconInterval[0] = pProbeRspHeader->beaconInterval[0];
1559 pBssInfo->beaconInterval[1] = pProbeRspHeader->beaconInterval[1];
1560
1561
1562 pBssInfo->capability[0] = pProbeRspHeader->capability[0];
1563 pBssInfo->capability[1] = pProbeRspHeader->capability[1];
1564
1565
1566 offset = 36;
1567 pBssInfo->frameBodysize = zfwBufGetSize(dev, buf)-offset;
1568 if (pBssInfo->frameBodysize > (ZM_MAX_PROBE_FRAME_BODY_SIZE-1))
1569 {
1570 pBssInfo->frameBodysize = ZM_MAX_PROBE_FRAME_BODY_SIZE-1;
1571 }
1572 accumulateLen = 0;
1573 do
1574 {
1575 eachIElength = zmw_rx_buf_readb(dev, buf, offset + accumulateLen+1) + 2;
1576
1577 if ( (eachIElength >= 2)
1578 && ((accumulateLen + eachIElength) <= pBssInfo->frameBodysize) )
1579 {
1580 zfCopyFromRxBuffer(dev, buf, pBssInfo->frameBody+accumulateLen, offset+accumulateLen, eachIElength);
1581 accumulateLen+=(u16_t)eachIElength;
1582 }
1583 else
1584 {
1585 zm_msg0_mm(ZM_LV_1, "probersp frameBodysize abnormal");
1586 break;
1587 }
1588 }
1589 while(accumulateLen < pBssInfo->frameBodysize);
1590 pBssInfo->frameBodysize = accumulateLen;
1591
1592
1593 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_SUPPORT_RATE)) == 0xffff )
1594 {
1595 zm_debug_msg0("EID(supported rates) not found");
1596 goto zlError;
1597 }
1598
1599 length = zmw_rx_buf_readb(dev, buf, offset+1);
1600 if ( length == 0 || length > ZM_MAX_SUPP_RATES_IE_SIZE)
1601 {
1602 zm_msg0_mm(ZM_LV_0, "Supported rates IE length abnormal");
1603 goto zlError;
1604 }
1605 zfCopyFromRxBuffer(dev, buf, pBssInfo->supportedRates, offset, length+2);
1606
1607
1608
1609
1610 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_COUNTRY)) != 0xffff )
1611 {
1612 length = zmw_rx_buf_readb(dev, buf, offset+1);
1613 if (length > ZM_MAX_COUNTRY_INFO_SIZE)
1614 {
1615 length = ZM_MAX_COUNTRY_INFO_SIZE;
1616 }
1617 zfCopyFromRxBuffer(dev, buf, pBssInfo->countryInfo, offset, length+2);
1618
1619 if (wd->sta.b802_11D)
1620 {
1621 zfHpGetRegulationTablefromISO(dev, (u8_t *)&pBssInfo->countryInfo, 3);
1622
1623 wd->sta.b802_11D = 0;
1624 }
1625 }
1626
1627
1628 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_ERP)) != 0xffff )
1629 {
1630 pBssInfo->erp = zmw_rx_buf_readb(dev, buf, offset+2);
1631 }
1632
1633
1634 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_RATE)) != 0xffff )
1635 {
1636 length = zmw_rx_buf_readb(dev, buf, offset+1);
1637 if (length > ZM_MAX_SUPP_RATES_IE_SIZE)
1638 {
1639 zm_msg0_mm(ZM_LV_0, "Extended rates IE length abnormal");
1640 goto zlError;
1641 }
1642 zfCopyFromRxBuffer(dev, buf, pBssInfo->extSupportedRates, offset, length+2);
1643 }
1644 else
1645 {
1646 pBssInfo->extSupportedRates[0] = 0;
1647 pBssInfo->extSupportedRates[1] = 0;
1648 }
1649
1650
1651 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_WPA_IE)) != 0xffff )
1652 {
1653 length = zmw_rx_buf_readb(dev, buf, offset+1);
1654 if (length > ZM_MAX_IE_SIZE)
1655 {
1656 length = ZM_MAX_IE_SIZE;
1657 }
1658 zfCopyFromRxBuffer(dev, buf, pBssInfo->wpaIe, offset, length+2);
1659 pBssInfo->securityType = ZM_SECURITY_TYPE_WPA;
1660 }
1661 else
1662 {
1663 pBssInfo->wpaIe[1] = 0;
1664 }
1665
1666
1667 if ((offset = zfFindWifiElement(dev, buf, 4, 0xff)) != 0xffff)
1668 {
1669 length = zmw_rx_buf_readb(dev, buf, offset+1);
1670 if (length > ZM_MAX_WPS_IE_SIZE )
1671 {
1672 length = ZM_MAX_WPS_IE_SIZE;
1673 }
1674 zfCopyFromRxBuffer(dev, buf, pBssInfo->wscIe, offset, length+2);
1675 }
1676 else
1677 {
1678 pBssInfo->wscIe[1] = 0;
1679 }
1680
1681
1682 if ((offset = zfFindSuperGElement(dev, buf, ZM_WLAN_EID_VENDOR_PRIVATE)) != 0xffff)
1683 {
1684 pBssInfo->apCap |= ZM_SuperG_AP;
1685 }
1686
1687
1688 if ((offset = zfFindXRElement(dev, buf, ZM_WLAN_EID_VENDOR_PRIVATE)) != 0xffff)
1689 {
1690 pBssInfo->apCap |= ZM_XR_AP;
1691 }
1692
1693
1694 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_RSN_IE)) != 0xffff )
1695 {
1696 length = zmw_rx_buf_readb(dev, buf, offset+1);
1697 if (length > ZM_MAX_IE_SIZE)
1698 {
1699 length = ZM_MAX_IE_SIZE;
1700 }
1701 zfCopyFromRxBuffer(dev, buf, pBssInfo->rsnIe, offset, length+2);
1702 pBssInfo->securityType = ZM_SECURITY_TYPE_WPA;
1703 }
1704 else
1705 {
1706 pBssInfo->rsnIe[1] = 0;
1707 }
1708#ifdef ZM_ENABLE_CENC
1709
1710 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_CENC_IE)) != 0xffff )
1711 {
1712 length = zmw_rx_buf_readb(dev, buf, offset+1);
1713 if (length > ZM_MAX_IE_SIZE )
1714 {
1715 length = ZM_MAX_IE_SIZE;
1716 }
1717 zfCopyFromRxBuffer(dev, buf, pBssInfo->cencIe, offset, length+2);
1718 pBssInfo->securityType = ZM_SECURITY_TYPE_CENC;
1719 pBssInfo->capability[0] &= 0xffef;
1720 }
1721 else
1722 {
1723 pBssInfo->cencIe[1] = 0;
1724 }
1725#endif
1726
1727
1728 {
1729 if ((offset = zfFindWifiElement(dev, buf, 2, 1)) != 0xffff)
1730 {
1731 apQosInfo = zmw_rx_buf_readb(dev, buf, offset+8) & 0x80;
1732 pBssInfo->wmeSupport = 1 | apQosInfo;
1733 }
1734 else if ((offset = zfFindWifiElement(dev, buf, 2, 0)) != 0xffff)
1735 {
1736 apQosInfo = zmw_rx_buf_readb(dev, buf, offset+8) & 0x80;
1737 pBssInfo->wmeSupport = 1 | apQosInfo;
1738 }
1739 else
1740 {
1741 pBssInfo->wmeSupport = 0;
1742 }
1743 }
1744
1745 if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_HT_CAPABILITY)) != 0xffff)
1746 {
1747
1748 pBssInfo->EnableHT = 1;
1749 if (zmw_rx_buf_readb(dev, buf, offset+1) & 0x02)
1750 {
1751 pBssInfo->enableHT40 = 1;
1752 }
1753 else
1754 {
1755 pBssInfo->enableHT40 = 0;
1756 }
1757
1758 if (zmw_rx_buf_readb(dev, buf, offset+1) & 0x40)
1759 {
1760 pBssInfo->SG40 = 1;
1761 }
1762 else
1763 {
1764 pBssInfo->SG40 = 0;
1765 }
1766 }
1767 else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTCAPABILITY)) != 0xffff)
1768 {
1769
1770 pBssInfo->EnableHT = 1;
1771 pBssInfo->apCap |= ZM_All11N_AP;
1772 if (zmw_rx_buf_readb(dev, buf, offset+2) & 0x02)
1773 {
1774 pBssInfo->enableHT40 = 1;
1775 }
1776 else
1777 {
1778 pBssInfo->enableHT40 = 0;
1779 }
1780
1781 if (zmw_rx_buf_readb(dev, buf, offset+2) & 0x40)
1782 {
1783 pBssInfo->SG40 = 1;
1784 }
1785 else
1786 {
1787 pBssInfo->SG40 = 0;
1788 }
1789 }
1790 else
1791 {
1792 pBssInfo->EnableHT = 0;
1793 }
1794
1795 if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY)) != 0xffff)
1796 {
1797
1798 pBssInfo->extChOffset = zmw_rx_buf_readb(dev, buf, offset+2) & 0x03;
1799 }
1800 else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTINFORMATION)) != 0xffff)
1801 {
1802
1803 pBssInfo->extChOffset = zmw_rx_buf_readb(dev, buf, offset+3) & 0x03;
1804 }
1805 else
1806 {
1807 pBssInfo->extChOffset = 0;
1808 }
1809
1810 if ( (pBssInfo->enableHT40 == 1)
1811 && ((pBssInfo->extChOffset != 1) && (pBssInfo->extChOffset != 3)) )
1812 {
1813 pBssInfo->enableHT40 = 0;
1814 }
1815
1816 if (pBssInfo->enableHT40 == 1)
1817 {
1818 if (zfHpIsAllowedChannel(dev, pBssInfo->frequency+((pBssInfo->extChOffset==1)?20:-20)) == 0)
1819 {
1820
1821 pBssInfo->EnableHT = 0;
1822 pBssInfo->enableHT40 = 0;
1823 pBssInfo->extChOffset = 0;
1824 }
1825 }
1826
1827
1828 if ( ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY)) != 0xffff)&&
1829 ((offset = zfFindBrdcmMrvlRlnkExtCap(dev, buf)) == 0xffff))
1830
1831 {
1832 pBssInfo->athOwlAp = 1;
1833 }
1834 else
1835 {
1836 pBssInfo->athOwlAp = 0;
1837 }
1838
1839
1840 if ( (pBssInfo->EnableHT == 1)
1841 && ((offset = zfFindBroadcomExtCap(dev, buf)) != 0xffff) )
1842 {
1843 pBssInfo->broadcomHTAp = 1;
1844 }
1845 else
1846 {
1847 pBssInfo->broadcomHTAp = 0;
1848 }
1849
1850
1851 if ((offset = zfFindMarvelExtCap(dev, buf)) != 0xffff)
1852 {
1853 pBssInfo->marvelAp = 1;
1854 }
1855 else
1856 {
1857 pBssInfo->marvelAp = 0;
1858 }
1859
1860
1861 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_IBSS)) != 0xffff )
1862 {
1863 pBssInfo->atimWindow = zmw_rx_buf_readh(dev, buf,offset+2);
1864 }
1865
1866
1867 if (pBssInfo->frequency > 3000) {
1868 if (wd->supportMode & ZM_WIRELESS_MODE_5_N) {
1869#if 0
1870 if (wd->supportMode & ZM_WIRELESS_MODE_5_54) {
1871
1872
1873 } else {
1874
1875
1876 if (!pBssInfo->EnableHT) {
1877 goto zlError2;
1878 }
1879 }
1880#endif
1881 } else {
1882 if (wd->supportMode & ZM_WIRELESS_MODE_5_54) {
1883
1884
1885 pBssInfo->EnableHT = 0;
1886 pBssInfo->enableHT40 = 0;
1887 pBssInfo->apCap &= (~ZM_All11N_AP);
1888 pBssInfo->extChOffset = 0;
1889 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1890 pBssInfo->frameBodysize, ZM_WLAN_EID_HT_CAPABILITY);
1891 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1892 pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTCAPABILITY);
1893 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1894 pBssInfo->frameBodysize, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY);
1895 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1896 pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTINFORMATION);
1897 } else {
1898
1899 goto zlError2;
1900 }
1901 }
1902 } else {
1903 if (wd->supportMode & ZM_WIRELESS_MODE_24_N) {
1904#if 0
1905 if (wd->supportMode & ZM_WIRELESS_MODE_24_54) {
1906 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1907
1908
1909 } else {
1910
1911
1912 if ( (!pBssInfo->EnableHT)
1913 && (pBssInfo->extSupportedRates[1] == 0) ) {
1914 goto zlError2;
1915 }
1916 }
1917 } else {
1918 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1919
1920
1921
1922
1923 if ( !pBssInfo->EnableHT ) {
1924 if ( zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->supportedRates)
1925 || zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->extSupportedRates) ) {
1926 goto zlError2;
1927 } else {
1928 zfGatherBMode(dev, pBssInfo->supportedRates,
1929 pBssInfo->extSupportedRates);
1930 pBssInfo->erp = 0;
1931
1932 pBssInfo->frameBodysize = zfRemoveElement(dev,
1933 pBssInfo->frameBody, pBssInfo->frameBodysize,
1934 ZM_WLAN_EID_ERP);
1935 pBssInfo->frameBodysize = zfRemoveElement(dev,
1936 pBssInfo->frameBody, pBssInfo->frameBodysize,
1937 ZM_WLAN_EID_EXTENDED_RATE);
1938
1939 pBssInfo->frameBodysize = zfUpdateElement(dev,
1940 pBssInfo->frameBody, pBssInfo->frameBodysize,
1941 pBssInfo->supportedRates);
1942 }
1943 }
1944 } else {
1945
1946
1947 if (!pBssInfo->EnableHT) {
1948 goto zlError2;
1949 }
1950 }
1951 }
1952#endif
1953 } else {
1954
1955 pBssInfo->EnableHT = 0;
1956 pBssInfo->enableHT40 = 0;
1957 pBssInfo->apCap &= (~ZM_All11N_AP);
1958 pBssInfo->extChOffset = 0;
1959 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1960 pBssInfo->frameBodysize, ZM_WLAN_EID_HT_CAPABILITY);
1961 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1962 pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTCAPABILITY);
1963 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1964 pBssInfo->frameBodysize, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY);
1965 pBssInfo->frameBodysize = zfRemoveElement(dev, pBssInfo->frameBody,
1966 pBssInfo->frameBodysize, ZM_WLAN_PREN2_EID_HTINFORMATION);
1967
1968 if (wd->supportMode & ZM_WIRELESS_MODE_24_54) {
1969#if 0
1970 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1971
1972
1973 } else {
1974
1975
1976
1977 if (pBssInfo->extSupportedRates[1] == 0) {
1978 goto zlError2;
1979 }
1980 }
1981#endif
1982 } else {
1983 if (wd->supportMode & ZM_WIRELESS_MODE_24_11) {
1984
1985
1986 if ( zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->supportedRates)
1987 || zfIsGOnlyMode(dev, pBssInfo->frequency, pBssInfo->extSupportedRates) ) {
1988 goto zlError2;
1989 } else {
1990 zfGatherBMode(dev, pBssInfo->supportedRates,
1991 pBssInfo->extSupportedRates);
1992 pBssInfo->erp = 0;
1993
1994 pBssInfo->frameBodysize = zfRemoveElement(dev,
1995 pBssInfo->frameBody, pBssInfo->frameBodysize,
1996 ZM_WLAN_EID_ERP);
1997 pBssInfo->frameBodysize = zfRemoveElement(dev,
1998 pBssInfo->frameBody, pBssInfo->frameBodysize,
1999 ZM_WLAN_EID_EXTENDED_RATE);
2000
2001 pBssInfo->frameBodysize = zfUpdateElement(dev,
2002 pBssInfo->frameBody, pBssInfo->frameBodysize,
2003 pBssInfo->supportedRates);
2004 }
2005 } else {
2006
2007 goto zlError2;
2008 }
2009 }
2010 }
2011 }
2012
2013 pBssInfo->flag |= ZM_BSS_INFO_VALID_BIT;
2014
2015zlUpdateRssi:
2016
2017 pBssInfo->tick = wd->tick;
2018
2019
2020 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_ERP)) != 0xffff )
2021 {
2022 pBssInfo->erp = zmw_rx_buf_readb(dev, buf, offset+2);
2023 }
2024
2025 if( (s8_t)pBssInfo->signalStrength < (s8_t)AddInfo->Tail.Data.SignalStrength1 )
2026 {
2027
2028 pBssInfo->signalStrength = (u8_t)AddInfo->Tail.Data.SignalStrength1;
2029
2030 pBssInfo->signalQuality = (u8_t)(AddInfo->Tail.Data.SignalStrength1 * 2);
2031
2032
2033 pBssInfo->sortValue = zfComputeBssInfoWeightValue(dev,
2034 (pBssInfo->supportedRates[6] + pBssInfo->extSupportedRates[0]),
2035 pBssInfo->EnableHT,
2036 pBssInfo->enableHT40,
2037 pBssInfo->signalStrength);
2038 }
2039
2040 return 0;
2041
2042zlError:
2043
2044 return 1;
2045
2046zlError2:
2047
2048 return 2;
2049}
2050
2051void zfStaProcessBeacon(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* AddInfo)
2052{
2053
2054 struct zsWlanBeaconFrameHeader* pBeaconHeader;
2055 struct zsBssInfo* pBssInfo;
2056 u8_t pBuf[sizeof(struct zsWlanBeaconFrameHeader)];
2057 u8_t bssid[6];
2058 int res;
2059
2060 zmw_get_wlan_dev(dev);
2061
2062 zmw_declare_for_critical_section();
2063
2064
2065 zfStaProtErpMonitor(dev, buf);
2066
2067 if (zfStaIsConnected(dev))
2068 {
2069 ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, bssid);
2070
2071 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
2072 {
2073 if ( zfRxBufferEqualToStr(dev, buf, bssid, ZM_WLAN_HEADER_A2_OFFSET, 6) )
2074 {
2075 zfPowerSavingMgrProcessBeacon(dev, buf);
2076 zfStaUpdateWmeParameter(dev, buf);
2077 if (wd->sta.DFSEnable)
2078 zfStaUpdateDot11HDFS(dev, buf);
2079 if (wd->sta.TPCEnable)
2080 zfStaUpdateDot11HTPC(dev, buf);
2081
2082 zfStaSignalStatistic(dev, AddInfo->Tail.Data.SignalStrength1,
2083 AddInfo->Tail.Data.SignalQuality);
2084 wd->sta.rxBeaconCount++;
2085 }
2086 }
2087 else if ( wd->wlanMode == ZM_MODE_IBSS )
2088 {
2089 if ( zfRxBufferEqualToStr(dev, buf, bssid, ZM_WLAN_HEADER_A3_OFFSET, 6) )
2090 {
2091 int res;
2092 struct zsPartnerNotifyEvent event;
2093
2094 zm_debug_msg0("20070916 Receive opposite Beacon!");
2095 zmw_enter_critical_section(dev);
2096 wd->sta.ibssReceiveBeaconCount++;
2097 zmw_leave_critical_section(dev);
2098
2099 res = zfStaSetOppositeInfoFromRxBuf(dev, buf);
2100 if ( res == 0 )
2101 {
2102
2103 zfInitPartnerNotifyEvent(dev, buf, &event);
2104 if (wd->zfcbIbssPartnerNotify != NULL)
2105 {
2106 wd->zfcbIbssPartnerNotify(dev, 1, &event);
2107 }
2108 }
2109
2110 zfStaSignalStatistic(dev, AddInfo->Tail.Data.SignalStrength1,
2111 AddInfo->Tail.Data.SignalQuality);
2112 }
2113
2114
2115
2116#if 0
2117 else if ( wd->sta.oppositeCount == 0 )
2118 {
2119 if ( (offset = zfFindElement(dev, buf, ZM_WLAN_EID_SSID)) != 0xffff )
2120 {
2121 if ( (wd->sta.ssidLen == zmw_buf_readb(dev, buf, offset+1))&&
2122 (zfRxBufferEqualToStr(dev, buf, wd->sta.ssid,
2123 offset+2, wd->sta.ssidLen)) )
2124 {
2125 capabilityInfo = zmw_buf_readh(dev, buf, 34);
2126
2127 if ( capabilityInfo & ZM_BIT_1 )
2128 {
2129 if ( (wd->sta.capability[0] & ZM_BIT_4) ==
2130 (capabilityInfo & ZM_BIT_4) )
2131 {
2132 zm_debug_msg0("IBSS merge");
2133 zfCopyFromRxBuffer(dev, buf, bssid,
2134 ZM_WLAN_HEADER_A3_OFFSET, 6);
2135 zfUpdateBssid(dev, bssid);
2136 }
2137 }
2138 }
2139 }
2140 }
2141#endif
2142 }
2143 }
2144
2145
2146 if ( !wd->sta.bChannelScan )
2147 {
2148 goto zlReturn;
2149 }
2150
2151 zfCopyFromRxBuffer(dev, buf, pBuf, 0, sizeof(struct zsWlanBeaconFrameHeader));
2152 pBeaconHeader = (struct zsWlanBeaconFrameHeader*) pBuf;
2153
2154 zmw_enter_critical_section(dev);
2155
2156
2157
2158 pBssInfo = zfStaFindBssInfo(dev, buf, pBeaconHeader);
2159
2160 if ( pBssInfo == NULL )
2161 {
2162
2163 pBssInfo = zfBssInfoAllocate(dev);
2164 if (pBssInfo != NULL)
2165 {
2166 res = zfStaInitBssInfo(dev, buf, pBeaconHeader, pBssInfo, AddInfo, 0);
2167
2168 if ( res != 0 )
2169 {
2170 zfBssInfoFree(dev, pBssInfo);
2171 }
2172 else
2173 {
2174 zfBssInfoInsertToList(dev, pBssInfo);
2175 }
2176 }
2177 }
2178 else
2179 {
2180 res = zfStaInitBssInfo(dev, buf, pBeaconHeader, pBssInfo, AddInfo, 1);
2181 if (res == 2)
2182 {
2183 zfBssInfoRemoveFromList(dev, pBssInfo);
2184 zfBssInfoFree(dev, pBssInfo);
2185 }
2186 else if ( wd->wlanMode == ZM_MODE_IBSS )
2187 {
2188 int idx;
2189
2190
2191 zfStaFindFreeOpposite(dev, (u16_t *)pBssInfo->macaddr, &idx);
2192 }
2193 }
2194
2195 zmw_leave_critical_section(dev);
2196
2197zlReturn:
2198
2199 return;
2200}
2201
2202
2203void zfAuthFreqCompleteCb(zdev_t* dev)
2204{
2205 zmw_get_wlan_dev(dev);
2206 zmw_declare_for_critical_section();
2207
2208 zmw_enter_critical_section(dev);
2209
2210 if (wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_COMPLETED)
2211 {
2212 zm_debug_msg0("ZM_STA_CONN_STATE_ASSOCIATE");
2213 wd->sta.connectTimer = wd->tick;
2214 wd->sta.connectState = ZM_STA_CONN_STATE_ASSOCIATE;
2215 }
2216
2217 zmw_leave_critical_section(dev);
2218 return;
2219}
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241void zfStaProcessAuth(zdev_t* dev, zbuf_t* buf, u16_t* src, u16_t apId)
2242{
2243 struct zsWlanAuthFrameHeader* pAuthFrame;
2244 u8_t pBuf[sizeof(struct zsWlanAuthFrameHeader)];
2245 u32_t p1, p2;
2246
2247 zmw_get_wlan_dev(dev);
2248 zmw_declare_for_critical_section();
2249
2250 if ( !zfStaIsConnecting(dev) )
2251 {
2252 return;
2253 }
2254
2255 pAuthFrame = (struct zsWlanAuthFrameHeader*) pBuf;
2256 zfCopyFromRxBuffer(dev, buf, pBuf, 0, sizeof(struct zsWlanAuthFrameHeader));
2257
2258 if ( wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_OPEN )
2259 {
2260 if ( (zmw_le16_to_cpu(pAuthFrame->seq) == 2)&&
2261 (zmw_le16_to_cpu(pAuthFrame->algo) == 0)&&
2262 (zmw_le16_to_cpu(pAuthFrame->status) == 0) )
2263 {
2264
2265 zmw_enter_critical_section(dev);
2266 wd->sta.connectTimer = wd->tick;
2267 zm_debug_msg0("ZM_STA_CONN_STATE_AUTH_COMPLETED");
2268 wd->sta.connectState = ZM_STA_CONN_STATE_AUTH_COMPLETED;
2269 zmw_leave_critical_section(dev);
2270
2271
2272
2273 zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
2274 wd->ExtOffset, zfAuthFreqCompleteCb);
2275
2276
2277 if ( wd->sta.connectByReasso )
2278 {
2279 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_REASOCREQ,
2280 wd->sta.bssid, 0, 0, 0);
2281 }
2282 else
2283 {
2284 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ASOCREQ,
2285 wd->sta.bssid, 0, 0, 0);
2286 }
2287
2288
2289 }
2290 else
2291 {
2292 zm_debug_msg1("authentication failed, status = ",
2293 pAuthFrame->status);
2294
2295 if (wd->sta.authMode == ZM_AUTH_MODE_AUTO)
2296 {
2297 wd->sta.bIsSharedKey = 1;
2298 zfStaStartConnect(dev, wd->sta.bIsSharedKey);
2299 }
2300 else
2301 {
2302 zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2303 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2304 }
2305 }
2306 }
2307 else if ( wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_1 )
2308 {
2309 if ( (zmw_le16_to_cpu(pAuthFrame->algo) == 1) &&
2310 (zmw_le16_to_cpu(pAuthFrame->seq) == 2) &&
2311 (zmw_le16_to_cpu(pAuthFrame->status) == 0))
2312
2313 {
2314 zfMemoryCopy(wd->sta.challengeText, pAuthFrame->challengeText,
2315 pAuthFrame->challengeText[1]+2);
2316
2317
2318 p1 = 0x30001;
2319 p2 = 0;
2320 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_AUTH,
2321 wd->sta.bssid, p1, p2, 0);
2322
2323 zmw_enter_critical_section(dev);
2324 wd->sta.connectTimer = wd->tick;
2325
2326 zm_debug_msg0("ZM_STA_SUB_STATE_AUTH_SHARE_2");
2327 wd->sta.connectState = ZM_STA_CONN_STATE_AUTH_SHARE_2;
2328 zmw_leave_critical_section(dev);
2329 }
2330 else
2331 {
2332 zm_debug_msg1("authentication failed, status = ",
2333 pAuthFrame->status);
2334
2335 zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2336 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2337 }
2338 }
2339 else if ( wd->sta.connectState == ZM_STA_CONN_STATE_AUTH_SHARE_2 )
2340 {
2341 if ( (zmw_le16_to_cpu(pAuthFrame->algo) == 1)&&
2342 (zmw_le16_to_cpu(pAuthFrame->seq) == 4)&&
2343 (zmw_le16_to_cpu(pAuthFrame->status) == 0) )
2344 {
2345
2346
2347 zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
2348 wd->ExtOffset, NULL);
2349
2350
2351 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_ASOCREQ,
2352 wd->sta.bssid, 0, 0, 0);
2353
2354 zmw_enter_critical_section(dev);
2355 wd->sta.connectTimer = wd->tick;
2356
2357 zm_debug_msg0("ZM_STA_SUB_STATE_ASSOCIATE");
2358 wd->sta.connectState = ZM_STA_CONN_STATE_ASSOCIATE;
2359 zmw_leave_critical_section(dev);
2360 }
2361 else
2362 {
2363 zm_debug_msg1("authentication failed, status = ",
2364 pAuthFrame->status);
2365
2366 zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2367 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2368 }
2369 }
2370 else
2371 {
2372 zm_debug_msg0("unknown case");
2373 }
2374}
2375
2376void zfStaProcessAsocReq(zdev_t* dev, zbuf_t* buf, u16_t* src, u16_t apId)
2377{
2378
2379 return;
2380}
2381
2382void zfStaProcessAsocRsp(zdev_t* dev, zbuf_t* buf)
2383{
2384 struct zsWlanAssoFrameHeader* pAssoFrame;
2385 u8_t pBuf[sizeof(struct zsWlanAssoFrameHeader)];
2386 u16_t offset;
2387 u32_t i;
2388 u32_t oneTxStreamCap;
2389
2390 zmw_get_wlan_dev(dev);
2391
2392 if ( !zfStaIsConnecting(dev) )
2393 {
2394 return;
2395 }
2396
2397 pAssoFrame = (struct zsWlanAssoFrameHeader*) pBuf;
2398 zfCopyFromRxBuffer(dev, buf, pBuf, 0, sizeof(struct zsWlanAssoFrameHeader));
2399
2400 if ( wd->sta.connectState == ZM_STA_CONN_STATE_ASSOCIATE )
2401 {
2402 if ( pAssoFrame->status == 0 )
2403 {
2404 zm_debug_msg0("ZM_STA_STATE_CONNECTED");
2405
2406 if (wd->sta.EnableHT == 1)
2407 {
2408 wd->sta.wmeConnected = 1;
2409 }
2410 if ((wd->sta.wmeEnabled & ZM_STA_WME_ENABLE_BIT) != 0)
2411 {
2412
2413 if ((offset = zfFindWifiElement(dev, buf, 2, 1)) != 0xffff)
2414 {
2415 zm_debug_msg0("WME enable");
2416 wd->sta.wmeConnected = 1;
2417 if ((wd->sta.wmeEnabled & ZM_STA_UAPSD_ENABLE_BIT) != 0)
2418 {
2419 if ((zmw_rx_buf_readb(dev, buf, offset+8) & 0x80) != 0)
2420 {
2421 zm_debug_msg0("UAPSD enable");
2422 wd->sta.qosInfo = wd->sta.wmeQosInfo;
2423 }
2424 }
2425
2426 zfStaUpdateWmeParameter(dev, buf);
2427 }
2428 }
2429
2430
2431
2432 wd->sta.asocRspFrameBodySize = zfwBufGetSize(dev, buf)-24;
2433 if (wd->sta.asocRspFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
2434 {
2435 wd->sta.asocRspFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
2436 }
2437 for (i=0; i<wd->sta.asocRspFrameBodySize; i++)
2438 {
2439 wd->sta.asocRspFrameBody[i] = zmw_rx_buf_readb(dev, buf, i+24);
2440 }
2441
2442 zfStaStoreAsocRspIe(dev, buf);
2443 if (wd->sta.EnableHT &&
2444 ((wd->sta.ie.HtCap.HtCapInfo & HTCAP_SupChannelWidthSet) != 0) &&
2445 (wd->ExtOffset != 0))
2446 {
2447 wd->sta.htCtrlBandwidth = 1;
2448 }
2449 else
2450 {
2451 wd->sta.htCtrlBandwidth = 0;
2452 }
2453
2454
2455
2456
2457
2458 if (wd->sta.EnableHT == 1)
2459 {
2460 wd->addbaComplete = 0;
2461
2462 if ((wd->sta.SWEncryptEnable & ZM_SW_TKIP_ENCRY_EN) == 0 &&
2463 (wd->sta.SWEncryptEnable & ZM_SW_WEP_ENCRY_EN) == 0)
2464 {
2465 wd->addbaCount = 1;
2466 zfAggSendAddbaRequest(dev, wd->sta.bssid, 0, 0);
2467 zfTimerSchedule(dev, ZM_EVENT_TIMEOUT_ADDBA, 100);
2468 }
2469 }
2470
2471
2472 if(wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode)
2473 {
2474 wd->sta.HT2040 = 1;
2475
2476 }
2477
2478 wd->sta.aid = pAssoFrame->aid & 0x3fff;
2479 wd->sta.oppositeCount = 0;
2480 zfStaSetOppositeInfoFromRxBuf(dev, buf);
2481
2482 wd->sta.rxBeaconCount = 16;
2483
2484 zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
2485 wd->sta.connPowerInHalfDbm = zfHpGetTransmitPower(dev);
2486 if (wd->zfcbConnectNotify != NULL)
2487 {
2488 if (wd->sta.EnableHT != 0)
2489 {
2490 oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
2491 if (wd->sta.htCtrlBandwidth == 1)
2492 {
2493 if(oneTxStreamCap)
2494 {
2495 if (wd->sta.SG40)
2496 {
2497 wd->CurrentTxRateKbps = 150000;
2498 wd->CurrentRxRateKbps = 300000;
2499 }
2500 else
2501 {
2502 wd->CurrentTxRateKbps = 135000;
2503 wd->CurrentRxRateKbps = 270000;
2504 }
2505 }
2506 else
2507 {
2508 if (wd->sta.SG40)
2509 {
2510 wd->CurrentTxRateKbps = 300000;
2511 wd->CurrentRxRateKbps = 300000;
2512 }
2513 else
2514 {
2515 wd->CurrentTxRateKbps = 270000;
2516 wd->CurrentRxRateKbps = 270000;
2517 }
2518 }
2519 }
2520 else
2521 {
2522 if(oneTxStreamCap)
2523 {
2524 wd->CurrentTxRateKbps = 650000;
2525 wd->CurrentRxRateKbps = 130000;
2526 }
2527 else
2528 {
2529 wd->CurrentTxRateKbps = 130000;
2530 wd->CurrentRxRateKbps = 130000;
2531 }
2532 }
2533 }
2534 else
2535 {
2536 if (wd->sta.connection_11b != 0)
2537 {
2538 wd->CurrentTxRateKbps = 11000;
2539 wd->CurrentRxRateKbps = 11000;
2540 }
2541 else
2542 {
2543 wd->CurrentTxRateKbps = 54000;
2544 wd->CurrentRxRateKbps = 54000;
2545 }
2546 }
2547
2548
2549 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
2550 }
2551 wd->sta.connectByReasso = TRUE;
2552 wd->sta.failCntOfReasso = 0;
2553
2554 zfPowerSavingMgrConnectNotify(dev);
2555
2556
2557
2558
2559
2560
2561
2562
2563 }
2564 else
2565 {
2566 zm_debug_msg1("association failed, status = ",
2567 pAssoFrame->status);
2568
2569 zm_debug_msg0("ZM_STA_STATE_DISCONNECT");
2570 wd->sta.connectByReasso = FALSE;
2571 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_ASOC_FAILED, wd->sta.bssid, 3);
2572 }
2573 }
2574
2575}
2576
2577void zfStaStoreAsocRspIe(zdev_t* dev, zbuf_t* buf)
2578{
2579 u16_t offset;
2580 u32_t i;
2581 u16_t length;
2582 u8_t *htcap;
2583 u8_t asocBw40 = 0;
2584 u8_t asocExtOffset = 0;
2585
2586 zmw_get_wlan_dev(dev);
2587
2588 for (i=0; i<wd->sta.asocRspFrameBodySize; i++)
2589 {
2590 wd->sta.asocRspFrameBody[i] = zmw_rx_buf_readb(dev, buf, i+24);
2591 }
2592
2593
2594 if ( ((wd->sta.currentFrequency > 3000) && !(wd->supportMode & ZM_WIRELESS_MODE_5_N))
2595 || ((wd->sta.currentFrequency < 3000) && !(wd->supportMode & ZM_WIRELESS_MODE_24_N)) )
2596 {
2597
2598 htcap = (u8_t *)&wd->sta.ie.HtCap;
2599 for (i=0; i<28; i++)
2600 {
2601 htcap[i] = 0;
2602 }
2603 wd->BandWidth40 = 0;
2604 wd->ExtOffset = 0;
2605 return;
2606 }
2607
2608 if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_HT_CAPABILITY)) != 0xffff)
2609 {
2610
2611 zm_debug_msg0("atheros pre n");
2612 htcap = (u8_t *)&wd->sta.ie.HtCap;
2613 htcap[0] = zmw_rx_buf_readb(dev, buf, offset);
2614 htcap[1] = 26;
2615 for (i=1; i<=26; i++)
2616 {
2617 htcap[i+1] = zmw_rx_buf_readb(dev, buf, offset + i);
2618 zm_msg2_mm(ZM_LV_1, "ASOC: HT Capabilities, htcap=", htcap[i+1]);
2619 }
2620 }
2621 else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTCAPABILITY)) != 0xffff)
2622 {
2623
2624 zm_debug_msg0("pre n 2.0 standard");
2625 htcap = (u8_t *)&wd->sta.ie.HtCap;
2626 for (i=0; i<28; i++)
2627 {
2628 htcap[i] = zmw_rx_buf_readb(dev, buf, offset + i);
2629 zm_msg2_mm(ZM_LV_1, "ASOC: HT Capabilities, htcap=", htcap[i]);
2630 }
2631 }
2632 else
2633 {
2634
2635 htcap = (u8_t *)&wd->sta.ie.HtCap;
2636 for (i=0; i<28; i++)
2637 {
2638 htcap[i] = 0;
2639 }
2640 wd->BandWidth40 = 0;
2641 wd->ExtOffset = 0;
2642 return;
2643 }
2644
2645 asocBw40 = (u8_t)((wd->sta.ie.HtCap.HtCapInfo & HTCAP_SupChannelWidthSet) >> 1);
2646
2647
2648 if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_EXTENDED_HT_CAPABILITY)) != 0xffff)
2649 {
2650
2651 zm_debug_msg0("atheros pre n HTINFO");
2652 length = 22;
2653 htcap = (u8_t *)&wd->sta.ie.HtInfo;
2654 htcap[0] = zmw_rx_buf_readb(dev, buf, offset);
2655 htcap[1] = 22;
2656 for (i=1; i<=22; i++)
2657 {
2658 htcap[i+1] = zmw_rx_buf_readb(dev, buf, offset + i);
2659 zm_msg2_mm(ZM_LV_1, "ASOC: HT Info, htinfo=", htcap[i+1]);
2660 }
2661 }
2662 else if ((offset = zfFindElement(dev, buf, ZM_WLAN_PREN2_EID_HTINFORMATION)) != 0xffff)
2663 {
2664
2665 zm_debug_msg0("pre n 2.0 standard HTINFO");
2666 length = zmw_rx_buf_readb(dev, buf, offset + 1);
2667 htcap = (u8_t *)&wd->sta.ie.HtInfo;
2668 for (i=0; i<24; i++)
2669 {
2670 htcap[i] = zmw_rx_buf_readb(dev, buf, offset + i);
2671 zm_msg2_mm(ZM_LV_1, "ASOC: HT Info, htinfo=", htcap[i]);
2672 }
2673 }
2674 else
2675 {
2676 zm_debug_msg0("no HTINFO");
2677 htcap = (u8_t *)&wd->sta.ie.HtInfo;
2678 for (i=0; i<24; i++)
2679 {
2680 htcap[i] = 0;
2681 }
2682 }
2683 asocExtOffset = wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_ExtChannelOffsetBelow;
2684
2685 if ((wd->sta.EnableHT == 1) && (asocBw40 == 1) && ((asocExtOffset == 1) || (asocExtOffset == 3)))
2686 {
2687 wd->BandWidth40 = asocBw40;
2688 wd->ExtOffset = asocExtOffset;
2689 }
2690 else
2691 {
2692 wd->BandWidth40 = 0;
2693 wd->ExtOffset = 0;
2694 }
2695
2696 return;
2697}
2698
2699void zfStaProcessDeauth(zdev_t* dev, zbuf_t* buf)
2700{
2701 u16_t apMacAddr[3];
2702
2703 zmw_get_wlan_dev(dev);
2704 zmw_declare_for_critical_section();
2705
2706
2707 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
2708 {
2709 apMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET);
2710 apMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+2);
2711 apMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+4);
2712 if ((apMacAddr[0] == wd->sta.bssid[0]) && (apMacAddr[1] == wd->sta.bssid[1]) && (apMacAddr[2] == wd->sta.bssid[2]))
2713 {
2714 if (zfwBufGetSize(dev, buf) >= 24+2)
2715 {
2716 if ( zfStaIsConnected(dev) )
2717 {
2718 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_DEAUTH, wd->sta.bssid, 2);
2719 }
2720 else if (zfStaIsConnecting(dev))
2721 {
2722 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_AUTH_FAILED, wd->sta.bssid, 3);
2723 }
2724 else
2725 {
2726 }
2727 }
2728 }
2729 }
2730 else if ( wd->wlanMode == ZM_MODE_IBSS )
2731 {
2732 u16_t peerMacAddr[3];
2733 u8_t peerIdx;
2734 s8_t res;
2735
2736 if ( zfStaIsConnected(dev) )
2737 {
2738 peerMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET);
2739 peerMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+2);
2740 peerMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+4);
2741
2742 zmw_enter_critical_section(dev);
2743 res = zfStaFindOppositeByMACAddr(dev, peerMacAddr, &peerIdx);
2744 if ( res == 0 )
2745 {
2746 wd->sta.oppositeInfo[peerIdx].aliveCounter = 0;
2747 }
2748 zmw_leave_critical_section(dev);
2749 }
2750 }
2751}
2752
2753void zfStaProcessDisasoc(zdev_t* dev, zbuf_t* buf)
2754{
2755 u16_t apMacAddr[3];
2756
2757 zmw_get_wlan_dev(dev);
2758
2759
2760 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
2761 {
2762 apMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET);
2763 apMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+2);
2764 apMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A3_OFFSET+4);
2765
2766 if ((apMacAddr[0] == wd->sta.bssid[0]) && (apMacAddr[1] == wd->sta.bssid[1]) && (apMacAddr[2] == wd->sta.bssid[2]))
2767 {
2768 if (zfwBufGetSize(dev, buf) >= 24+2)
2769 {
2770 if ( zfStaIsConnected(dev) )
2771 {
2772 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_DISASOC, wd->sta.bssid, 2);
2773 }
2774 else
2775 {
2776 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_ASOC_FAILED, wd->sta.bssid, 3);
2777 }
2778 }
2779 }
2780 }
2781}
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801void zfStaProcessProbeReq(zdev_t* dev, zbuf_t* buf, u16_t* src)
2802{
2803 u16_t offset;
2804 u8_t len;
2805 u16_t i, j;
2806 u16_t sendFlag;
2807
2808 zmw_get_wlan_dev(dev);
2809
2810
2811 if ((wd->wlanMode != ZM_MODE_AP) || (wd->wlanMode != ZM_MODE_IBSS))
2812 {
2813 zm_msg0_mm(ZM_LV_3, "Ignore probe req");
2814 return;
2815 }
2816
2817
2818 if ((offset = zfFindElement(dev, buf, ZM_WLAN_EID_SSID)) == 0xffff)
2819 {
2820 zm_msg0_mm(ZM_LV_3, "probe req SSID not found");
2821 return;
2822 }
2823
2824 len = zmw_rx_buf_readb(dev, buf, offset+1);
2825
2826 for (i=0; i<ZM_MAX_AP_SUPPORT; i++)
2827 {
2828 if ((wd->ap.apBitmap & (i<<i)) != 0)
2829 {
2830 sendFlag = 0;
2831
2832 if ((len == 0) && (wd->ap.hideSsid[i] == 0))
2833 {
2834 sendFlag = 1;
2835 }
2836
2837 else if (wd->ap.ssidLen[i] == len)
2838 {
2839 for (j=0; j<len; j++)
2840 {
2841 if (zmw_rx_buf_readb(dev, buf, offset+1+j)
2842 != wd->ap.ssid[i][j])
2843 {
2844 break;
2845 }
2846 }
2847 if (j == len)
2848 {
2849 sendFlag = 1;
2850 }
2851 }
2852 if (sendFlag == 1)
2853 {
2854
2855 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_PROBERSP, src, i, 0, 0);
2856 }
2857 }
2858 }
2859}
2860
2861void zfStaProcessProbeRsp(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* AddInfo)
2862{
2863
2864
2865
2866
2867 #if 0
2868 zmw_get_wlan_dev(dev);
2869
2870 if ( !wd->sta.bChannelScan )
2871 {
2872 return;
2873 }
2874 #endif
2875
2876 zfProcessProbeRsp(dev, buf, AddInfo);
2877}
2878
2879void zfIBSSSetupBssDesc(zdev_t *dev)
2880{
2881#ifdef ZM_ENABLE_IBSS_WPA2PSK
2882 u8_t i;
2883#endif
2884 struct zsBssInfo *pBssInfo;
2885 u16_t offset = 0;
2886
2887 zmw_get_wlan_dev(dev);
2888
2889 pBssInfo = &wd->sta.ibssBssDesc;
2890 zfZeroMemory((u8_t *)pBssInfo, sizeof(struct zsBssInfo));
2891
2892 pBssInfo->signalStrength = 100;
2893
2894 zfMemoryCopy((u8_t *)pBssInfo->macaddr, (u8_t *)wd->macAddr,6);
2895 zfMemoryCopy((u8_t *)pBssInfo->bssid, (u8_t *)wd->sta.bssid, 6);
2896
2897 pBssInfo->beaconInterval[0] = (u8_t)(wd->beaconInterval) ;
2898 pBssInfo->beaconInterval[1] = (u8_t)((wd->beaconInterval) >> 8) ;
2899
2900 pBssInfo->capability[0] = wd->sta.capability[0];
2901 pBssInfo->capability[1] = wd->sta.capability[1];
2902
2903 pBssInfo->ssid[0] = ZM_WLAN_EID_SSID;
2904 pBssInfo->ssid[1] = wd->sta.ssidLen;
2905 zfMemoryCopy((u8_t *)&pBssInfo->ssid[2], (u8_t *)wd->sta.ssid, wd->sta.ssidLen);
2906 zfMemoryCopy((u8_t *)&pBssInfo->frameBody[offset], (u8_t *)pBssInfo->ssid,
2907 wd->sta.ssidLen + 2);
2908 offset += wd->sta.ssidLen + 2;
2909
2910
2911
2912
2913 pBssInfo->channel = zfChFreqToNum(wd->frequency, NULL);
2914 pBssInfo->frequency = wd->frequency;
2915 pBssInfo->atimWindow = wd->sta.atimWindow;
2916
2917#ifdef ZM_ENABLE_IBSS_WPA2PSK
2918 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
2919 {
2920 u8_t rsn[64]=
2921 {
2922
2923 0x30,
2924
2925 0x14,
2926
2927 0x01, 0x00,
2928
2929 0x00, 0x0f, 0xac, 0x04,
2930
2931 0x01, 0x00,
2932
2933 0x00, 0x0f, 0xac, 0x02,
2934
2935 0x01, 0x00,
2936
2937 0x00, 0x0f, 0xac, 0x02,
2938
2939 0x00, 0x00
2940 };
2941
2942
2943 zfMemoryCopy(rsn+4, zgWpa2AesOui, 4);
2944
2945 if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
2946 {
2947
2948 zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
2949 }
2950
2951
2952 pBssInfo->frameBody[offset++] = ZM_WLAN_EID_RSN_IE ;
2953
2954
2955 pBssInfo->frameBody[offset++] = rsn[1] ;
2956
2957
2958 for(i=0; i<rsn[1]; i++)
2959 {
2960 pBssInfo->frameBody[offset++] = rsn[i+2] ;
2961 }
2962
2963 zfMemoryCopy(pBssInfo->rsnIe, rsn, rsn[1]+2);
2964 }
2965#endif
2966}
2967
2968void zfIbssConnectNetwork(zdev_t* dev)
2969{
2970 struct zsBssInfo* pBssInfo;
2971 struct zsBssInfo tmpBssInfo;
2972 u8_t macAddr[6], bssid[6], bssNotFound = TRUE;
2973 u16_t i, j=100;
2974 u16_t k;
2975 struct zsPartnerNotifyEvent event;
2976 u32_t channelFlags;
2977 u16_t oppositeWepStatus;
2978
2979 zmw_get_wlan_dev(dev);
2980
2981 zmw_declare_for_critical_section();
2982
2983
2984 zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTING);
2985 zfPowerSavingMgrWakeup(dev);
2986
2987
2988 zfUpdateDefaultQosParameter(dev, 0);
2989
2990 wd->sta.bProtectionMode = FALSE;
2991 zfHpSetSlotTime(dev, 1);
2992
2993
2994 wd->sta.capability[0] &= ~ZM_BIT_0;
2995
2996 wd->sta.capability[0] |= ZM_BIT_1;
2997
2998 wd->sta.capability[1] &= ~ZM_BIT_2;
2999
3000 wd->sta.wmeConnected = 0;
3001 wd->sta.psMgr.tempWakeUp = 0;
3002 wd->sta.qosInfo = 0;
3003 wd->sta.EnableHT = 0;
3004 wd->BandWidth40 = 0;
3005 wd->ExtOffset = 0;
3006
3007 if ( wd->sta.bssList.bssCount )
3008 {
3009
3010 zfBssInfoReorderList(dev);
3011
3012 zmw_enter_critical_section(dev);
3013
3014 pBssInfo = wd->sta.bssList.head;
3015
3016 for(i=0; i<wd->sta.bssList.bssCount; i++)
3017 {
3018
3019 if ( pBssInfo->capability[0] & ZM_BIT_4 )
3020 {
3021
3022 oppositeWepStatus = ZM_ENCRYPTION_WEP_ENABLED;
3023
3024 if ( pBssInfo->rsnIe[1] != 0 )
3025 {
3026 if ( (pBssInfo->rsnIe[7] == 0x01) || (pBssInfo->rsnIe[7] == 0x05) )
3027 {
3028
3029 oppositeWepStatus = ZM_ENCRYPTION_WEP_ENABLED;
3030 }
3031 else if ( pBssInfo->rsnIe[7] == 0x02 )
3032 {
3033
3034 oppositeWepStatus = ZM_ENCRYPTION_TKIP;
3035 }
3036 else if ( pBssInfo->rsnIe[7] == 0x04 )
3037 {
3038
3039 oppositeWepStatus = ZM_ENCRYPTION_AES;
3040 }
3041 }
3042 }
3043 else
3044 {
3045
3046 oppositeWepStatus = ZM_ENCRYPTION_WEP_DISABLED;
3047 }
3048
3049 if ( (zfMemoryIsEqual(&(pBssInfo->ssid[2]), wd->sta.ssid,
3050 wd->sta.ssidLen))&&
3051 (wd->sta.ssidLen == pBssInfo->ssid[1])&&
3052 (oppositeWepStatus == wd->sta.wepStatus) )
3053 {
3054
3055 if (pBssInfo->frequency > 3000) {
3056 if ( (pBssInfo->EnableHT == 1)
3057 || (pBssInfo->apCap & ZM_All11N_AP) )
3058 {
3059 channelFlags = CHANNEL_A_HT;
3060 if (pBssInfo->enableHT40 == 1) {
3061 channelFlags |= CHANNEL_HT40;
3062 }
3063 } else {
3064 channelFlags = CHANNEL_A;
3065 }
3066 } else {
3067 if ( (pBssInfo->EnableHT == 1)
3068 || (pBssInfo->apCap & ZM_All11N_AP) )
3069 {
3070 channelFlags = CHANNEL_G_HT;
3071 if(pBssInfo->enableHT40 == 1) {
3072 channelFlags |= CHANNEL_HT40;
3073 }
3074 } else {
3075 if (pBssInfo->extSupportedRates[1] == 0) {
3076 channelFlags = CHANNEL_B;
3077 } else {
3078 channelFlags = CHANNEL_G;
3079 }
3080 }
3081 }
3082
3083 if ( ((channelFlags == CHANNEL_B) && (wd->connectMode & ZM_BIT_0))
3084 || ((channelFlags == CHANNEL_G) && (wd->connectMode & ZM_BIT_1))
3085 || ((channelFlags == CHANNEL_A) && (wd->connectMode & ZM_BIT_2))
3086 || ((channelFlags & CHANNEL_HT20) && (wd->connectMode & ZM_BIT_3)) )
3087 {
3088 pBssInfo = pBssInfo->next;
3089 continue;
3090 }
3091
3092
3093 if (zfHpIsDfsChannelNCS(dev, pBssInfo->frequency))
3094 {
3095 zm_debug_msg0("Bypass DFS channel");
3096 continue;
3097 }
3098
3099
3100 if ( pBssInfo->capability[0] & ZM_BIT_1 )
3101 {
3102
3103 j = i;
3104 break;
3105 }
3106 }
3107
3108 pBssInfo = pBssInfo->next;
3109 }
3110
3111 if ((j < wd->sta.bssList.bssCount) && (pBssInfo != NULL))
3112 {
3113 zfwMemoryCopy((u8_t*)&tmpBssInfo, (u8_t*)(pBssInfo), sizeof(struct zsBssInfo));
3114 pBssInfo = &tmpBssInfo;
3115 }
3116 else
3117 {
3118 pBssInfo = NULL;
3119 }
3120
3121 zmw_leave_critical_section(dev);
3122
3123
3124 if (pBssInfo != NULL)
3125 {
3126 int res;
3127
3128 zm_debug_msg0("IBSS found");
3129
3130
3131 zmw_enter_critical_section(dev);
3132 wd->sta.bssNotFoundCount = 0;
3133 zmw_leave_critical_section(dev);
3134
3135 bssNotFound = FALSE;
3136 wd->sta.atimWindow = pBssInfo->atimWindow;
3137 wd->frequency = pBssInfo->frequency;
3138
3139 zfCoreSetFrequency(dev, wd->frequency);
3140 zfUpdateBssid(dev, pBssInfo->bssid);
3141 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_ZERO);
3142 zfUpdateSupportRate(dev, pBssInfo->supportedRates);
3143 zfUpdateSupportRate(dev, pBssInfo->extSupportedRates);
3144 wd->beaconInterval = pBssInfo->beaconInterval[0] +
3145 (((u16_t) pBssInfo->beaconInterval[1]) << 8);
3146
3147 if (wd->beaconInterval == 0)
3148 {
3149 wd->beaconInterval = 100;
3150 }
3151
3152
3153 if ( pBssInfo->rsnIe[1] != 0 )
3154 {
3155 zfMemoryCopy(wd->sta.rsnIe, pBssInfo->rsnIe,
3156 pBssInfo->rsnIe[1]+2);
3157
3158#ifdef ZM_ENABLE_IBSS_WPA2PSK
3159
3160 zmw_enter_critical_section(dev);
3161 wd->sta.ibssWpa2Psk = 1;
3162 zmw_leave_critical_section(dev);
3163#endif
3164 }
3165 else
3166 {
3167 wd->sta.rsnIe[1] = 0;
3168 }
3169
3170
3171 if ( pBssInfo->capability[0] & ZM_BIT_4 )
3172 {
3173 wd->sta.capability[0] |= ZM_BIT_4;
3174 }
3175 else
3176 {
3177 wd->sta.capability[0] &= ~ZM_BIT_4;
3178 }
3179
3180
3181 wd->preambleTypeInUsed = wd->preambleType;
3182 if ( wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_AUTO )
3183 {
3184 if (pBssInfo->capability[0] & ZM_BIT_5)
3185 {
3186 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;
3187 }
3188 else
3189 {
3190 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_LONG;
3191 }
3192 }
3193
3194 if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_LONG)
3195 {
3196 wd->sta.capability[0] &= ~ZM_BIT_5;
3197 }
3198 else
3199 {
3200 wd->sta.capability[0] |= ZM_BIT_5;
3201 }
3202
3203 wd->sta.beaconFrameBodySize = pBssInfo->frameBodysize + 12;
3204
3205 if (wd->sta.beaconFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
3206 {
3207 wd->sta.beaconFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
3208 }
3209
3210 for (k=0; k<8; k++)
3211 {
3212 wd->sta.beaconFrameBody[k] = pBssInfo->timeStamp[k];
3213 }
3214 wd->sta.beaconFrameBody[8] = pBssInfo->beaconInterval[0];
3215 wd->sta.beaconFrameBody[9] = pBssInfo->beaconInterval[1];
3216 wd->sta.beaconFrameBody[10] = pBssInfo->capability[0];
3217 wd->sta.beaconFrameBody[11] = pBssInfo->capability[1];
3218
3219 for (k=0; k<pBssInfo->frameBodysize; k++)
3220 {
3221 wd->sta.beaconFrameBody[k+12] = pBssInfo->frameBody[k];
3222 }
3223
3224 zmw_enter_critical_section(dev);
3225 res = zfStaSetOppositeInfoFromBSSInfo(dev, pBssInfo);
3226 if ( res == 0 )
3227 {
3228 zfMemoryCopy(event.bssid, (u8_t *)(pBssInfo->bssid), 6);
3229 zfMemoryCopy(event.peerMacAddr, (u8_t *)(pBssInfo->macaddr), 6);
3230 }
3231 zmw_leave_critical_section(dev);
3232
3233
3234 goto connect_done;
3235 }
3236 }
3237
3238
3239 if ( bssNotFound )
3240 {
3241#ifdef ZM_ENABLE_IBSS_WPA2PSK
3242 u16_t offset ;
3243#endif
3244 if ( wd->sta.ibssJoinOnly )
3245 {
3246 zm_debug_msg0("IBSS join only...retry...");
3247 goto retry_ibss;
3248 }
3249
3250 if(wd->sta.bssNotFoundCount<2)
3251 {
3252 zmw_enter_critical_section(dev);
3253 zm_debug_msg1("IBSS not found, do sitesurvey!! bssNotFoundCount=", wd->sta.bssNotFoundCount);
3254 wd->sta.bssNotFoundCount++;
3255 zmw_leave_critical_section(dev);
3256 goto retry_ibss;
3257 }
3258 else
3259 {
3260 zmw_enter_critical_section(dev);
3261
3262 wd->sta.bssNotFoundCount = 0;
3263 zmw_leave_critical_section(dev);
3264 }
3265
3266
3267 if (zfHpIsDfsChannel(dev, wd->frequency))
3268 {
3269 wd->frequency = zfHpFindFirstNonDfsChannel(dev, wd->frequency > 3000);
3270 }
3271
3272 if( wd->ws.autoSetFrequency == 0 )
3273 {
3274 zm_debug_msg1("Create Ad Hoc Network Band ", wd->ws.adhocMode);
3275 wd->frequency = zfFindCleanFrequency(dev, wd->ws.adhocMode);
3276 wd->ws.autoSetFrequency = 0xff;
3277 }
3278 zm_debug_msg1("IBSS not found, created one in channel ", wd->frequency);
3279
3280 wd->sta.ibssBssIsCreator = 1;
3281
3282
3283 zfCoreSetFrequency(dev, wd->frequency);
3284 if (wd->sta.bDesiredBssid == TRUE)
3285 {
3286 for (k=0; k<6; k++)
3287 {
3288 bssid[k] = wd->sta.desiredBssid[k];
3289 }
3290 }
3291 else
3292 {
3293 #if 1
3294 macAddr[0] = (wd->macAddr[0] & 0xff);
3295 macAddr[1] = (wd->macAddr[0] >> 8);
3296 macAddr[2] = (wd->macAddr[1] & 0xff);
3297 macAddr[3] = (wd->macAddr[1] >> 8);
3298 macAddr[4] = (wd->macAddr[2] & 0xff);
3299 macAddr[5] = (wd->macAddr[2] >> 8);
3300 zfGenerateRandomBSSID(dev, (u8_t *)wd->macAddr, (u8_t *)bssid);
3301 #else
3302 for (k=0; k<6; k++)
3303 {
3304 bssid[k] = (u8_t) zfGetRandomNumber(dev, 0);
3305 }
3306 bssid[0] &= ~ZM_BIT_0;
3307 bssid[0] |= ZM_BIT_1;
3308 #endif
3309 }
3310
3311 zfUpdateBssid(dev, bssid);
3312
3313
3314
3315 if(wd->frequency <= ZM_CH_G_14)
3316 {
3317 if ( wd->wfc.bIbssGMode
3318 && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
3319 {
3320 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_IBSS_AG);
3321 }
3322 else
3323 {
3324 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_IBSS_B);
3325 }
3326 } else {
3327 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_IBSS_AG);
3328 }
3329
3330 if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_DISABLED )
3331 {
3332 wd->sta.capability[0] &= ~ZM_BIT_4;
3333 }
3334 else
3335 {
3336 wd->sta.capability[0] |= ZM_BIT_4;
3337 }
3338
3339 wd->preambleTypeInUsed = wd->preambleType;
3340 if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_LONG)
3341 {
3342 wd->sta.capability[0] &= ~ZM_BIT_5;
3343 }
3344 else
3345 {
3346 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;
3347 wd->sta.capability[0] |= ZM_BIT_5;
3348 }
3349
3350 zfIBSSSetupBssDesc(dev);
3351
3352#ifdef ZM_ENABLE_IBSS_WPA2PSK
3353
3354
3355 offset = 0 ;
3356
3357
3358 offset += 8 ;
3359
3360
3361 wd->sta.beaconFrameBody[offset++] = (u8_t)(wd->beaconInterval) ;
3362 wd->sta.beaconFrameBody[offset++] = (u8_t)((wd->beaconInterval) >> 8) ;
3363
3364
3365 wd->sta.beaconFrameBody[offset++] = wd->sta.capability[0] ;
3366 wd->sta.beaconFrameBody[offset++] = wd->sta.capability[1] ;
3367 #if 0
3368
3369
3370 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_SSID ;
3371
3372 wd->sta.beaconFrameBody[offset++] = wd->sta.ssidLen ;
3373
3374 for(i=0; i<wd->sta.ssidLen; i++)
3375 {
3376 wd->sta.beaconFrameBody[offset++] = wd->sta.ssid[i] ;
3377 }
3378
3379
3380 rateSet = ZM_RATE_SET_CCK ;
3381 if ( (rateSet == ZM_RATE_SET_OFDM)&&((wd->gRate & 0xff) == 0) )
3382 {
3383 offset += 0 ;
3384 }
3385 else
3386 {
3387
3388 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_SUPPORT_RATE ;
3389
3390
3391 lenOffset = offset++;
3392
3393
3394 for (i=0; i<4; i++)
3395 {
3396 if ((wd->bRate & (0x1<<i)) == (0x1<<i))
3397 {
3398 wd->sta.beaconFrameBody[offset++] =
3399 zg11bRateTbl[i]+((wd->bRateBasic & (0x1<<i))<<(7-i)) ;
3400 len++;
3401 }
3402 }
3403
3404
3405 wd->sta.beaconFrameBody[lenOffset] = len ;
3406 }
3407
3408
3409
3410 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_DS ;
3411
3412
3413 wd->sta.beaconFrameBody[offset++] = 1 ;
3414
3415
3416 wd->sta.beaconFrameBody[offset++] =
3417 zfChFreqToNum(wd->frequency, NULL) ;
3418
3419
3420
3421 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_IBSS ;
3422
3423
3424 wd->sta.beaconFrameBody[offset++] = 2 ;
3425
3426
3427 wd->sta.beaconFrameBody[offset] = wd->sta.atimWindow ;
3428 offset += 2 ;
3429
3430
3431 if ( wd->wfc.bIbssGMode
3432 && (wd->supportMode & (ZM_WIRELESS_MODE_24_54|ZM_WIRELESS_MODE_24_N)) )
3433 {
3434
3435 wd->erpElement = 0;
3436
3437 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_ERP ;
3438
3439
3440 wd->sta.beaconFrameBody[offset++] = 1 ;
3441
3442
3443 wd->sta.beaconFrameBody[offset++] = wd->erpElement ;
3444
3445
3446 if ( (rateSet == ZM_RATE_SET_OFDM)&&((wd->gRate & 0xff) == 0) )
3447 {
3448 offset += 0 ;
3449 }
3450 else
3451 {
3452 len = 0 ;
3453
3454
3455 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_EXTENDED_RATE ;
3456
3457
3458 lenOffset = offset++ ;
3459
3460
3461 for (i=0; i<8; i++)
3462 {
3463 if ((wd->gRate & (0x1<<i)) == (0x1<<i))
3464 {
3465 wd->sta.beaconFrameBody[offset++] =
3466 zg11gRateTbl[i]+((wd->gRateBasic & (0x1<<i))<<(7-i));
3467 len++;
3468 }
3469 }
3470
3471
3472 wd->sta.beaconFrameBody[lenOffset] = len ;
3473 }
3474 }
3475 #endif
3476
3477
3478 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
3479 {
3480 u8_t frameType = ZM_WLAN_FRAME_TYPE_AUTH ;
3481 u8_t rsn[64]=
3482 {
3483
3484 0x30,
3485
3486 0x14,
3487
3488 0x01, 0x00,
3489
3490 0x00, 0x0f, 0xac, 0x04,
3491
3492 0x01, 0x00,
3493
3494 0x00, 0x0f, 0xac, 0x02,
3495
3496 0x01, 0x00,
3497
3498 0x00, 0x0f, 0xac, 0x02,
3499
3500 0x00, 0x00
3501 };
3502
3503
3504 zfMemoryCopy(rsn+4, zgWpa2AesOui, 4);
3505
3506 if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
3507 {
3508
3509 zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
3510 }
3511
3512
3513 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_RSN_IE ;
3514
3515
3516 wd->sta.beaconFrameBody[offset++] = rsn[1] ;
3517
3518
3519 for(i=0; i<rsn[1]; i++)
3520 wd->sta.beaconFrameBody[offset++] = rsn[i+2] ;
3521
3522 zfMemoryCopy(wd->sta.rsnIe, rsn, rsn[1]+2);
3523
3524#ifdef ZM_ENABLE_IBSS_WPA2PSK
3525
3526 zmw_enter_critical_section(dev);
3527 wd->sta.ibssWpa2Psk = 1;
3528 zmw_leave_critical_section(dev);
3529#endif
3530 }
3531
3532 #if 0
3533
3534 {
3535 u8_t OUI[3] = { 0x0 , 0x90 , 0x4C } ;
3536
3537 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_WPA_IE ;
3538
3539 wd->sta.beaconFrameBody[offset++] = wd->sta.HTCap.Data.Length + 4 ;
3540
3541 for (i = 0; i < 3; i++)
3542 {
3543 wd->sta.beaconFrameBody[offset++] = OUI[i] ;
3544 }
3545
3546 wd->sta.beaconFrameBody[offset++] = wd->sta.HTCap.Data.ElementID ;
3547
3548 for (i = 0; i < 26; i++)
3549 {
3550 wd->sta.beaconFrameBody[offset++] = wd->sta.HTCap.Byte[i+2] ;
3551 }
3552 }
3553
3554
3555 {
3556 u8_t OUI[3] = { 0x0 , 0x90 , 0x4C } ;
3557
3558 wd->sta.beaconFrameBody[offset++] = ZM_WLAN_EID_WPA_IE ;
3559
3560 wd->sta.beaconFrameBody[offset++] = wd->sta.ExtHTCap.Data.Length + 4 ;
3561
3562 for (i = 0; i < 3; i++)
3563 {
3564 wd->sta.beaconFrameBody[offset++] = OUI[i] ;
3565 }
3566
3567 wd->sta.beaconFrameBody[offset++] = wd->sta.ExtHTCap.Data.ElementID ;
3568
3569 for (i = 0; i < 22; i++)
3570 {
3571 wd->sta.beaconFrameBody[offset++] = wd->sta.ExtHTCap.Byte[i+2] ;
3572 }
3573 }
3574 #endif
3575
3576 wd->sta.beaconFrameBodySize = offset ;
3577
3578 if (wd->sta.beaconFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
3579 {
3580 wd->sta.beaconFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
3581 }
3582
3583
3584
3585
3586 printk("The capability info 1 = %02x\n", wd->sta.capability[0]) ;
3587 printk("The capability info 2 = %02x\n", wd->sta.capability[1]) ;
3588 for(k=0; k<wd->sta.beaconFrameBodySize; k++)
3589 {
3590 printk("%02x ", wd->sta.beaconFrameBody[k]) ;
3591 }
3592 #if 0
3593 zmw_enter_critical_section(dev);
3594 zfMemoryCopy(event.bssid, (u8_t *)bssid, 6);
3595 zfMemoryCopy(event.peerMacAddr, (u8_t *)wd->macAddr, 6);
3596 zmw_leave_critical_section(dev);
3597 #endif
3598#endif
3599
3600
3601
3602
3603 }
3604 else
3605 {
3606 wd->sta.ibssBssIsCreator = 0;
3607 }
3608
3609connect_done:
3610 zfHpEnableBeacon(dev, ZM_MODE_IBSS, wd->beaconInterval, wd->dtim, (u8_t)wd->sta.atimWindow);
3611 zfStaSendBeacon(dev);
3612 zfHpSetAtimWindow(dev, wd->sta.atimWindow);
3613
3614
3615 zmw_enter_critical_section(dev);
3616 zfTimerSchedule(dev, ZM_EVENT_IBSS_MONITOR, ZM_TICK_IBSS_MONITOR);
3617 zmw_leave_critical_section(dev);
3618
3619
3620 if (wd->zfcbConnectNotify != NULL)
3621 {
3622 wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
3623 }
3624 zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
3625 wd->sta.connPowerInHalfDbm = zfHpGetTransmitPower(dev);
3626
3627#ifdef ZM_ENABLE_IBSS_DELAYED_JOIN_INDICATION
3628 if ( !bssNotFound )
3629 {
3630 wd->sta.ibssDelayedInd = 1;
3631 zfMemoryCopy((u8_t *)&wd->sta.ibssDelayedIndEvent, (u8_t *)&event, sizeof(struct zsPartnerNotifyEvent));
3632 }
3633#else
3634 if ( !bssNotFound )
3635 {
3636 if (wd->zfcbIbssPartnerNotify != NULL)
3637 {
3638 wd->zfcbIbssPartnerNotify(dev, 1, &event);
3639 }
3640 }
3641#endif
3642
3643 return;
3644
3645retry_ibss:
3646 zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTING);
3647 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_NOT_FOUND, wd->sta.bssid, 0);
3648 return;
3649}
3650
3651void zfStaProcessAtim(zdev_t* dev, zbuf_t* buf)
3652{
3653 zmw_get_wlan_dev(dev);
3654
3655 zm_debug_msg0("Receiving Atim window notification");
3656
3657 wd->sta.recvAtim = 1;
3658}
3659
3660static struct zsBssInfo* zfInfraFindAPToConnect(zdev_t* dev,
3661 struct zsBssInfo* candidateBss)
3662{
3663 struct zsBssInfo* pBssInfo;
3664 struct zsBssInfo* pNowBssInfo=NULL;
3665 u16_t i;
3666 u16_t ret, apWepStatus;
3667 u32_t k;
3668 u32_t channelFlags;
3669
3670 zmw_get_wlan_dev(dev);
3671 zmw_declare_for_critical_section();
3672
3673 zmw_enter_critical_section(dev);
3674
3675 pBssInfo = wd->sta.bssList.head;
3676
3677 for(i=0; i<wd->sta.bssList.bssCount; i++)
3678 {
3679 if ( pBssInfo->capability[0] & ZM_BIT_4 )
3680 {
3681 apWepStatus = ZM_ENCRYPTION_WEP_ENABLED;
3682 }
3683 else
3684 {
3685 apWepStatus = ZM_ENCRYPTION_WEP_DISABLED;
3686 }
3687
3688 if ( ((zfMemoryIsEqual(&(pBssInfo->ssid[2]), wd->sta.ssid,
3689 wd->sta.ssidLen))&&
3690 (wd->sta.ssidLen == pBssInfo->ssid[1]))||
3691 ((wd->sta.ssidLen == 0)&&
3692
3693 (wd->sta.wepStatus == apWepStatus )&&
3694 (pBssInfo->securityType != ZM_SECURITY_TYPE_WPA) ))
3695 {
3696 if ( wd->sta.ssidLen == 0 )
3697 {
3698 zm_debug_msg0("ANY BSS found");
3699 }
3700
3701 if ( ((wd->sta.wepStatus == ZM_ENCRYPTION_WEP_DISABLED && apWepStatus == ZM_ENCRYPTION_WEP_ENABLED) ||
3702 (wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED &&
3703 (apWepStatus == ZM_ENCRYPTION_WEP_DISABLED && wd->sta.dropUnencryptedPkts == 1))) &&
3704 (wd->sta.authMode >= ZM_AUTH_MODE_OPEN && wd->sta.authMode <= ZM_AUTH_MODE_AUTO) )
3705 {
3706 zm_debug_msg0("Privacy policy is inconsistent");
3707 pBssInfo = pBssInfo->next;
3708 continue;
3709 }
3710
3711
3712 if ( !zfCheckAuthentication(dev, pBssInfo) )
3713 {
3714 pBssInfo = pBssInfo->next;
3715 continue;
3716 }
3717
3718
3719 if (wd->sta.bDesiredBssid == TRUE)
3720 {
3721 for (k=0; k<6; k++)
3722 {
3723 if (wd->sta.desiredBssid[k] != pBssInfo->bssid[k])
3724 {
3725 zm_msg0_mm(ZM_LV_1, "desired bssid not matched 1");
3726 break;
3727 }
3728 }
3729
3730 if (k != 6)
3731 {
3732 zm_msg0_mm(ZM_LV_1, "desired bssid not matched 2");
3733 pBssInfo = pBssInfo->next;
3734 continue;
3735 }
3736 }
3737
3738
3739 if (pBssInfo->frequency > 3000) {
3740 if ( (pBssInfo->EnableHT == 1)
3741 || (pBssInfo->apCap & ZM_All11N_AP) )
3742 {
3743 channelFlags = CHANNEL_A_HT;
3744 if (pBssInfo->enableHT40 == 1) {
3745 channelFlags |= CHANNEL_HT40;
3746 }
3747 } else {
3748 channelFlags = CHANNEL_A;
3749 }
3750 } else {
3751 if ( (pBssInfo->EnableHT == 1)
3752 || (pBssInfo->apCap & ZM_All11N_AP) )
3753 {
3754 channelFlags = CHANNEL_G_HT;
3755 if(pBssInfo->enableHT40 == 1) {
3756 channelFlags |= CHANNEL_HT40;
3757 }
3758 } else {
3759 if (pBssInfo->extSupportedRates[1] == 0) {
3760 channelFlags = CHANNEL_B;
3761 } else {
3762 channelFlags = CHANNEL_G;
3763 }
3764 }
3765 }
3766
3767 if ( ((channelFlags == CHANNEL_B) && (wd->connectMode & ZM_BIT_0))
3768 || ((channelFlags == CHANNEL_G) && (wd->connectMode & ZM_BIT_1))
3769 || ((channelFlags == CHANNEL_A) && (wd->connectMode & ZM_BIT_2))
3770 || ((channelFlags & CHANNEL_HT20) && (wd->connectMode & ZM_BIT_3)) )
3771 {
3772 pBssInfo = pBssInfo->next;
3773 continue;
3774 }
3775
3776
3777 if ((ret = zfStaIsApInBlockingList(dev, pBssInfo->bssid)) == TRUE)
3778 {
3779 zm_msg0_mm(ZM_LV_0, "Candidate AP in blocking List, skip if there's stilla choice!");
3780 pNowBssInfo = pBssInfo;
3781 pBssInfo = pBssInfo->next;
3782 continue;
3783 }
3784
3785 if ( pBssInfo->capability[0] & ZM_BIT_0 )
3786 {
3787 pNowBssInfo = pBssInfo;
3788 wd->sta.apWmeCapability = pBssInfo->wmeSupport;
3789
3790
3791 goto done;
3792 }
3793 }
3794
3795 pBssInfo = pBssInfo->next;
3796 }
3797
3798done:
3799 if (pNowBssInfo != NULL)
3800 {
3801 zfwMemoryCopy((void*)candidateBss, (void*)pNowBssInfo, sizeof(struct zsBssInfo));
3802 pNowBssInfo = candidateBss;
3803 }
3804
3805 zmw_leave_critical_section(dev);
3806
3807 return pNowBssInfo;
3808}
3809
3810
3811void zfInfraConnectNetwork(zdev_t* dev)
3812{
3813 struct zsBssInfo* pBssInfo;
3814 struct zsBssInfo* pNowBssInfo=NULL;
3815 struct zsBssInfo candidateBss;
3816
3817
3818 u8_t ret=FALSE;
3819 u16_t k;
3820 u8_t density = ZM_MPDU_DENSITY_NONE;
3821
3822 zmw_get_wlan_dev(dev);
3823 zmw_declare_for_critical_section();
3824
3825
3826
3827 zmw_enter_critical_section(dev);
3828 wd->sta.bssNotFoundCount = 0;
3829 zmw_leave_critical_section(dev);
3830
3831
3832 zfUpdateDefaultQosParameter(dev, 0);
3833
3834 zfStaRefreshBlockList(dev, 0);
3835
3836
3837 zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTING);
3838 zfPowerSavingMgrWakeup(dev);
3839
3840 wd->sta.wmeConnected = 0;
3841 wd->sta.psMgr.tempWakeUp = 0;
3842 wd->sta.qosInfo = 0;
3843 zfQueueFlush(dev, wd->sta.uapsdQ);
3844
3845 wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
3846
3847
3848 zfBssInfoReorderList(dev);
3849
3850 pNowBssInfo = zfInfraFindAPToConnect(dev, &candidateBss);
3851
3852 if (wd->sta.SWEncryptEnable != 0)
3853 {
3854 if (wd->sta.bSafeMode == 0)
3855 {
3856 zfStaDisableSWEncryption(dev);
3857 }
3858 }
3859 if ( pNowBssInfo != NULL )
3860 {
3861
3862
3863 pBssInfo = pNowBssInfo;
3864 wd->sta.ssidLen = pBssInfo->ssid[1];
3865 zfMemoryCopy(wd->sta.ssid, &(pBssInfo->ssid[2]), pBssInfo->ssid[1]);
3866 wd->frequency = pBssInfo->frequency;
3867
3868
3869
3870 zfUpdateBssid(dev, pBssInfo->bssid);
3871 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_ZERO);
3872 zfUpdateSupportRate(dev, pBssInfo->supportedRates);
3873 zfUpdateSupportRate(dev, pBssInfo->extSupportedRates);
3874
3875 wd->beaconInterval = pBssInfo->beaconInterval[0] +
3876 (((u16_t) pBssInfo->beaconInterval[1]) << 8);
3877 if (wd->beaconInterval == 0)
3878 {
3879 wd->beaconInterval = 100;
3880 }
3881
3882
3883 wd->sta.capability[0] |= ZM_BIT_0;
3884
3885 wd->sta.capability[0] &= ~ZM_BIT_1;
3886
3887
3888 wd->sta.EnableHT = pBssInfo->EnableHT;
3889 wd->sta.SG40 = pBssInfo->SG40;
3890#ifdef ZM_ENABLE_CENC
3891 if ( pBssInfo->securityType == ZM_SECURITY_TYPE_CENC )
3892 {
3893 wd->sta.wmeEnabled = 0;
3894 cencInit(dev);
3895 cencSetCENCMode(dev, NdisCENC_PSK);
3896 wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;
3897
3898 if ( pBssInfo->cencIe[1] != 0 )
3899 {
3900
3901
3902 zfwCencHandleBeaconProbrespon(dev, (u8_t *)&pBssInfo->cencIe,
3903 (u8_t *)&pBssInfo->ssid, (u8_t *)&pBssInfo->macaddr);
3904 zfMemoryCopy(wd->sta.cencIe, pBssInfo->cencIe,
3905 pBssInfo->cencIe[1]+2);
3906 }
3907 else
3908 {
3909 wd->sta.cencIe[1] = 0;
3910 }
3911 }
3912#endif
3913 if ( pBssInfo->securityType == ZM_SECURITY_TYPE_WPA )
3914 {
3915 wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;
3916
3917 if ( wd->sta.wepStatus == ZM_ENCRYPTION_TKIP )
3918 {
3919 wd->sta.encryMode = ZM_TKIP;
3920
3921
3922 if (wd->sta.EnableHT == 1)
3923 {
3924 zfStaEnableSWEncryption(dev, (ZM_SW_TKIP_ENCRY_EN|ZM_SW_TKIP_DECRY_EN));
3925 }
3926
3927
3928
3929
3930 }
3931 else if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
3932 {
3933 wd->sta.encryMode = ZM_AES;
3934
3935
3936 if (wd->sta.EnableHT)
3937 {
3938
3939 density = ZM_MPDU_DENSITY_8US;
3940 }
3941 }
3942
3943 if ( pBssInfo->wpaIe[1] != 0 )
3944 {
3945 zfMemoryCopy(wd->sta.wpaIe, pBssInfo->wpaIe,
3946 pBssInfo->wpaIe[1]+2);
3947 }
3948 else
3949 {
3950 wd->sta.wpaIe[1] = 0;
3951 }
3952
3953 if ( pBssInfo->rsnIe[1] != 0 )
3954 {
3955 zfMemoryCopy(wd->sta.rsnIe, pBssInfo->rsnIe,
3956 pBssInfo->rsnIe[1]+2);
3957 }
3958 else
3959 {
3960 wd->sta.rsnIe[1] = 0;
3961 }
3962 }
3963
3964
3965
3966
3967 wd->preambleTypeInUsed = wd->preambleType;
3968 if ( wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_AUTO )
3969 {
3970 if (pBssInfo->capability[0] & ZM_BIT_5)
3971 {
3972 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;
3973 }
3974 else
3975 {
3976 wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_LONG;
3977 }
3978 }
3979
3980 if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_LONG)
3981 {
3982 wd->sta.capability[0] &= ~ZM_BIT_5;
3983 }
3984 else
3985 {
3986 wd->sta.capability[0] |= ZM_BIT_5;
3987 }
3988
3989
3990 if ((pBssInfo->enableHT40 == 1) &&
3991 ((pBssInfo->extChOffset == 1) || (pBssInfo->extChOffset == 3)))
3992 {
3993 wd->BandWidth40 = pBssInfo->enableHT40;
3994 wd->ExtOffset = pBssInfo->extChOffset;
3995 }
3996 else
3997 {
3998 wd->BandWidth40 = 0;
3999 wd->ExtOffset = 0;
4000 }
4001
4002
4003
4004
4005 if ( pBssInfo->athOwlAp & ZM_BIT_0 )
4006 {
4007
4008
4009
4010 zfHpDisableHwRetry(dev);
4011 wd->sta.athOwlAp = 1;
4012
4013 density = ZM_MPDU_DENSITY_8US;
4014 }
4015 else
4016 {
4017
4018
4019
4020 zfHpEnableHwRetry(dev);
4021 wd->sta.athOwlAp = 0;
4022 }
4023 wd->reorder = 1;
4024
4025
4026 zfHpSetMPDUDensity(dev, density);
4027
4028
4029 if ( pBssInfo->capability[1] & ZM_BIT_2 )
4030 {
4031 wd->sta.capability[1] |= ZM_BIT_2;
4032 }
4033
4034 if ( pBssInfo->erp & ZM_BIT_1 )
4035 {
4036
4037 wd->sta.bProtectionMode = TRUE;
4038 zfHpSetSlotTime(dev, 0);
4039 }
4040 else
4041 {
4042
4043 wd->sta.bProtectionMode = FALSE;
4044 zfHpSetSlotTime(dev, 1);
4045 }
4046
4047 if (pBssInfo->marvelAp == 1)
4048 {
4049 wd->sta.enableDrvBA = 0;
4050
4051
4052
4053
4054 zfHpSetSlotTimeRegister(dev, 0);
4055 }
4056 else
4057 {
4058 wd->sta.enableDrvBA = 1;
4059
4060
4061
4062
4063
4064
4065 zfHpSetSlotTimeRegister(dev, 1);
4066 }
4067
4068
4069 wd->sta.beaconFrameBodySize = pBssInfo->frameBodysize + 12;
4070 if (wd->sta.beaconFrameBodySize > ZM_CACHED_FRAMEBODY_SIZE)
4071 {
4072 wd->sta.beaconFrameBodySize = ZM_CACHED_FRAMEBODY_SIZE;
4073 }
4074 for (k=0; k<8; k++)
4075 {
4076 wd->sta.beaconFrameBody[k] = pBssInfo->timeStamp[k];
4077 }
4078 wd->sta.beaconFrameBody[8] = pBssInfo->beaconInterval[0];
4079 wd->sta.beaconFrameBody[9] = pBssInfo->beaconInterval[1];
4080 wd->sta.beaconFrameBody[10] = pBssInfo->capability[0];
4081 wd->sta.beaconFrameBody[11] = pBssInfo->capability[1];
4082 for (k=0; k<(wd->sta.beaconFrameBodySize - 12); k++)
4083 {
4084 wd->sta.beaconFrameBody[k+12] = pBssInfo->frameBody[k];
4085 }
4086
4087 if ( ( pBssInfo->capability[0] & ZM_BIT_4 )&&
4088 (( wd->sta.authMode == ZM_AUTH_MODE_OPEN )||
4089 ( wd->sta.authMode == ZM_AUTH_MODE_SHARED_KEY)||
4090 (wd->sta.authMode == ZM_AUTH_MODE_AUTO)) )
4091 {
4092
4093 if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_DISABLED )
4094 {
4095 zm_debug_msg0("Adapter is no WEP, try to connect to WEP AP");
4096 ret = FALSE;
4097 }
4098
4099
4100 if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED )
4101 {
4102
4103 if (wd->sta.EnableHT == 1)
4104 {
4105 zfStaEnableSWEncryption(dev, (ZM_SW_WEP_ENCRY_EN|ZM_SW_WEP_DECRY_EN));
4106 }
4107
4108
4109
4110
4111 }
4112
4113 wd->sta.capability[0] |= ZM_BIT_4;
4114
4115 if ( wd->sta.authMode == ZM_AUTH_MODE_AUTO )
4116 {
4117 if ( (wd->sta.connectTimeoutCount % 2) == 0 )
4118 wd->sta.bIsSharedKey = 0;
4119 else
4120 wd->sta.bIsSharedKey = 1;
4121 }
4122 else if ( wd->sta.authMode != ZM_AUTH_MODE_SHARED_KEY )
4123 {
4124
4125 wd->sta.bIsSharedKey = 0;
4126 }
4127 else if ( wd->sta.authMode != ZM_AUTH_MODE_OPEN )
4128 {
4129
4130 wd->sta.bIsSharedKey = 1;
4131 }
4132 }
4133 else
4134 {
4135 if ( (pBssInfo->securityType == ZM_SECURITY_TYPE_WPA)||
4136 (pBssInfo->capability[0] & ZM_BIT_4) )
4137 {
4138 wd->sta.capability[0] |= ZM_BIT_4;
4139
4140 }
4141 else
4142 {
4143 wd->sta.capability[0] &= (~ZM_BIT_4);
4144 }
4145
4146
4147
4148 wd->sta.bIsSharedKey = 0;
4149 }
4150
4151
4152
4153
4154
4155
4156
4157
4158
4159
4160
4161
4162
4163 }
4164 else
4165 {
4166 zm_debug_msg0("Desired SSID not found");
4167 goto zlConnectFailed;
4168 }
4169
4170
4171 zfCoreSetFrequencyV2(dev, wd->frequency, zfStaStartConnectCb);
4172 return;
4173
4174zlConnectFailed:
4175 zfStaConnectFail(dev, ZM_STATUS_MEDIA_DISCONNECT_NOT_FOUND, wd->sta.bssid, 0);
4176 return;
4177}
4178
4179u8_t zfCheckWPAAuth(zdev_t* dev, struct zsBssInfo* pBssInfo)
4180{
4181 u8_t ret=TRUE;
4182 u8_t pmkCount;
4183 u8_t i;
4184 u16_t encAlgoType = 0;
4185
4186 zmw_get_wlan_dev(dev);
4187
4188 if ( wd->sta.wepStatus == ZM_ENCRYPTION_TKIP )
4189 {
4190 encAlgoType = ZM_TKIP;
4191 }
4192 else if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4193 {
4194 encAlgoType = ZM_AES;
4195 }
4196
4197 switch(wd->sta.authMode)
4198 {
4199 case ZM_AUTH_MODE_WPA:
4200 case ZM_AUTH_MODE_WPAPSK:
4201 if ( pBssInfo->wpaIe[1] == 0 )
4202 {
4203 ret = FALSE;
4204 break;
4205 }
4206
4207 pmkCount = pBssInfo->wpaIe[12];
4208 for(i=0; i < pmkCount; i++)
4209 {
4210 if ( pBssInfo->wpaIe[17 + 4*i] == encAlgoType )
4211 {
4212 ret = TRUE;
4213 goto done;
4214 }
4215 }
4216
4217 ret = FALSE;
4218 break;
4219
4220 case ZM_AUTH_MODE_WPA2:
4221 case ZM_AUTH_MODE_WPA2PSK:
4222 if ( pBssInfo->rsnIe[1] == 0 )
4223 {
4224 ret = FALSE;
4225 break;
4226 }
4227
4228 pmkCount = pBssInfo->rsnIe[8];
4229 for(i=0; i < pmkCount; i++)
4230 {
4231 if ( pBssInfo->rsnIe[13 + 4*i] == encAlgoType )
4232 {
4233 ret = TRUE;
4234 goto done;
4235 }
4236 }
4237
4238 ret = FALSE;
4239 break;
4240 }
4241
4242done:
4243 return ret;
4244}
4245
4246u8_t zfCheckAuthentication(zdev_t* dev, struct zsBssInfo* pBssInfo)
4247{
4248 u8_t ret=TRUE;
4249 u16_t encAlgoType;
4250 u16_t UnicastCipherNum;
4251
4252 zmw_get_wlan_dev(dev);
4253
4254
4255 if ( wd->sta.ssidLen == 0 )
4256 {
4257 return ret;
4258 }
4259
4260
4261 switch(wd->sta.authMode)
4262
4263 {
4264 case ZM_AUTH_MODE_WPA_AUTO:
4265 case ZM_AUTH_MODE_WPAPSK_AUTO:
4266 encAlgoType = 0;
4267 if(pBssInfo->rsnIe[1] != 0)
4268 {
4269 UnicastCipherNum = (pBssInfo->rsnIe[8]) +
4270 (pBssInfo->rsnIe[9] << 8);
4271
4272
4273 if (UnicastCipherNum == 1)
4274 {
4275 encAlgoType = pBssInfo->rsnIe[13];
4276
4277 }
4278 else
4279 {
4280 u16_t ii;
4281 u16_t desiredCipher = 0;
4282 u16_t IEOffSet = 13;
4283
4284
4285 for (ii = 0; ii < UnicastCipherNum; ii++)
4286 {
4287 if (pBssInfo->rsnIe[IEOffSet+ii*4] > desiredCipher)
4288 {
4289 desiredCipher = pBssInfo->rsnIe[IEOffSet+ii*4];
4290 }
4291 }
4292
4293 encAlgoType = desiredCipher;
4294 }
4295
4296 if ( encAlgoType == 0x02 )
4297 {
4298 wd->sta.wepStatus = ZM_ENCRYPTION_TKIP;
4299
4300 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4301 {
4302 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2;
4303 }
4304 else
4305 {
4306 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2PSK;
4307 }
4308 }
4309 else if ( encAlgoType == 0x04 )
4310 {
4311 wd->sta.wepStatus = ZM_ENCRYPTION_AES;
4312
4313 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4314 {
4315 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2;
4316 }
4317 else
4318 {
4319 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA2PSK;
4320 }
4321 }
4322 else
4323 {
4324 ret = FALSE;
4325 }
4326 }
4327 else if(pBssInfo->wpaIe[1] != 0)
4328 {
4329 UnicastCipherNum = (pBssInfo->wpaIe[12]) +
4330 (pBssInfo->wpaIe[13] << 8);
4331
4332
4333 if (UnicastCipherNum == 1)
4334 {
4335 encAlgoType = pBssInfo->wpaIe[17];
4336
4337 }
4338 else
4339 {
4340 u16_t ii;
4341 u16_t desiredCipher = 0;
4342 u16_t IEOffSet = 17;
4343
4344
4345 for (ii = 0; ii < UnicastCipherNum; ii++)
4346 {
4347 if (pBssInfo->wpaIe[IEOffSet+ii*4] > desiredCipher)
4348 {
4349 desiredCipher = pBssInfo->wpaIe[IEOffSet+ii*4];
4350 }
4351 }
4352
4353 encAlgoType = desiredCipher;
4354 }
4355
4356 if ( encAlgoType == 0x02 )
4357 {
4358 wd->sta.wepStatus = ZM_ENCRYPTION_TKIP;
4359
4360 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4361 {
4362 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA;
4363 }
4364 else
4365 {
4366 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPAPSK;
4367 }
4368 }
4369 else if ( encAlgoType == 0x04 )
4370 {
4371 wd->sta.wepStatus = ZM_ENCRYPTION_AES;
4372
4373 if ( wd->sta.authMode == ZM_AUTH_MODE_WPA_AUTO )
4374 {
4375 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPA;
4376 }
4377 else
4378 {
4379 wd->sta.currentAuthMode = ZM_AUTH_MODE_WPAPSK;
4380 }
4381 }
4382 else
4383 {
4384 ret = FALSE;
4385 }
4386
4387
4388 }
4389 else
4390 {
4391 ret = FALSE;
4392 }
4393
4394 break;
4395
4396 case ZM_AUTH_MODE_WPA:
4397 case ZM_AUTH_MODE_WPAPSK:
4398 case ZM_AUTH_MODE_WPA_NONE:
4399 case ZM_AUTH_MODE_WPA2:
4400 case ZM_AUTH_MODE_WPA2PSK:
4401 {
4402 if ( pBssInfo->securityType != ZM_SECURITY_TYPE_WPA )
4403 {
4404 ret = FALSE;
4405 }
4406
4407 ret = zfCheckWPAAuth(dev, pBssInfo);
4408 }
4409 break;
4410
4411 case ZM_AUTH_MODE_OPEN:
4412 case ZM_AUTH_MODE_SHARED_KEY:
4413 case ZM_AUTH_MODE_AUTO:
4414 {
4415 if ( pBssInfo->wscIe[1] )
4416 {
4417
4418 break;
4419 }
4420 else if ( pBssInfo->securityType == ZM_SECURITY_TYPE_WPA )
4421 {
4422 ret = FALSE;
4423 }
4424 }
4425 break;
4426
4427 default:
4428 break;
4429 }
4430
4431 return ret;
4432}
4433
4434u8_t zfStaIsConnected(zdev_t* dev)
4435{
4436 zmw_get_wlan_dev(dev);
4437
4438 if ( wd->sta.adapterState == ZM_STA_STATE_CONNECTED )
4439 {
4440 return TRUE;
4441 }
4442
4443 return FALSE;
4444}
4445
4446u8_t zfStaIsConnecting(zdev_t* dev)
4447{
4448 zmw_get_wlan_dev(dev);
4449
4450 if ( wd->sta.adapterState == ZM_STA_STATE_CONNECTING )
4451 {
4452 return TRUE;
4453 }
4454
4455 return FALSE;
4456}
4457
4458u8_t zfStaIsDisconnect(zdev_t* dev)
4459{
4460 zmw_get_wlan_dev(dev);
4461
4462 if ( wd->sta.adapterState == ZM_STA_STATE_DISCONNECT )
4463 {
4464 return TRUE;
4465 }
4466
4467 return FALSE;
4468}
4469
4470u8_t zfChangeAdapterState(zdev_t* dev, u8_t newState)
4471{
4472 u8_t ret = TRUE;
4473
4474 zmw_get_wlan_dev(dev);
4475
4476 zmw_declare_for_critical_section();
4477
4478
4479
4480
4481
4482
4483 switch(newState)
4484 {
4485 case ZM_STA_STATE_DISCONNECT:
4486 zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_DISCONNECT);
4487
4488 #if 1
4489 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
4490 #else
4491 if ( wd->sta.bChannelScan )
4492 {
4493
4494 wd->sta.bChannelScan = FALSE;
4495 ret = TRUE;
4496 break;
4497 }
4498 #endif
4499
4500 break;
4501 case ZM_STA_STATE_CONNECTING:
4502 #if 1
4503 zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
4504 #else
4505 if ( wd->sta.bChannelScan )
4506 {
4507
4508 wd->sta.bChannelScan = FALSE;
4509 ret = TRUE;
4510 break;
4511 }
4512 #endif
4513
4514 break;
4515 case ZM_STA_STATE_CONNECTED:
4516 break;
4517 default:
4518 break;
4519 }
4520
4521
4522
4523 zmw_enter_critical_section(dev);
4524 wd->sta.adapterState = newState;
4525 zmw_leave_critical_section(dev);
4526
4527 zm_debug_msg1("change adapter state = ", newState);
4528
4529
4530 return ret;
4531}
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550u16_t zfStaAddIeSsid(zdev_t* dev, zbuf_t* buf, u16_t offset)
4551{
4552 u16_t i;
4553
4554 zmw_get_wlan_dev(dev);
4555
4556
4557 zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_SSID);
4558
4559
4560 zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.ssidLen);
4561
4562
4563 for (i=0; i<wd->sta.ssidLen; i++)
4564 {
4565 zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.ssid[i]);
4566 }
4567
4568 return offset;
4569}
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
4584
4585
4586
4587
4588u16_t zfStaAddIeWpaRsn(zdev_t* dev, zbuf_t* buf, u16_t offset, u8_t frameType)
4589{
4590 u32_t i;
4591 u8_t ssn[64]={
4592
4593 0xdd,
4594
4595 0x18,
4596
4597 0x00, 0x50, 0xf2, 0x01,
4598
4599 0x01, 0x00,
4600
4601 0x00, 0x50, 0xf2, 0x02,
4602
4603 0x01, 0x00,
4604
4605 0x00, 0x50, 0xf2, 0x02,
4606
4607 0x01, 0x00,
4608
4609 0x00, 0x50, 0xf2, 0x02,
4610
4611 0x00, 0x00
4612 };
4613
4614 u8_t rsn[64]={
4615
4616 0x30,
4617
4618 0x14,
4619
4620 0x01, 0x00,
4621
4622 0x00, 0x0f, 0xac, 0x02,
4623
4624 0x01, 0x00,
4625
4626 0x00, 0x0f, 0xac, 0x02,
4627
4628 0x01, 0x00,
4629
4630 0x00, 0x0f, 0xac, 0x02,
4631
4632 0x00, 0x00
4633 };
4634
4635 zmw_get_wlan_dev(dev);
4636
4637 if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPAPSK )
4638 {
4639
4640 zfMemoryCopy(ssn+8, wd->sta.wpaIe+8, 4);
4641
4642 if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4643 {
4644
4645 zfMemoryCopy(ssn+14, zgWpaAesOui, 4);
4646 }
4647
4648 zfCopyToIntTxBuffer(dev, buf, ssn, offset, ssn[1]+2);
4649 zfMemoryCopy(wd->sta.wpaIe, ssn, ssn[1]+2);
4650 offset += (ssn[1]+2);
4651 }
4652 else if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPA )
4653 {
4654
4655 zfMemoryCopy(ssn+8, wd->sta.wpaIe+8, 4);
4656
4657 zfMemoryCopy(ssn+20, zgWpaRadiusOui, 4);
4658
4659 if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4660 {
4661
4662 zfMemoryCopy(ssn+14, zgWpaAesOui, 4);
4663 }
4664
4665 zfCopyToIntTxBuffer(dev, buf, ssn, offset, ssn[1]+2);
4666 zfMemoryCopy(wd->sta.wpaIe, ssn, ssn[1]+2);
4667 offset += (ssn[1]+2);
4668 }
4669 else if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPA2PSK )
4670 {
4671
4672 zfMemoryCopy(rsn+4, wd->sta.rsnIe+4, 4);
4673
4674 if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4675 {
4676
4677 zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
4678 }
4679
4680 if ( frameType == ZM_WLAN_FRAME_TYPE_REASOCREQ )
4681 {
4682 for(i=0; i<wd->sta.pmkidInfo.bssidCount; i++)
4683 {
4684 if ( zfMemoryIsEqual((u8_t*) wd->sta.pmkidInfo.bssidInfo[i].bssid,
4685 (u8_t*) wd->sta.bssid, 6) )
4686 {
4687
4688 break;
4689 }
4690
4691 if ( i < wd->sta.pmkidInfo.bssidCount )
4692 {
4693
4694 rsn[22] = 0x01;
4695 rsn[23] = 0x00;
4696
4697
4698 zfMemoryCopy(rsn+24,
4699 wd->sta.pmkidInfo.bssidInfo[i].pmkid, 16);
4700 rsn[1] += 18;
4701 }
4702 }
4703 }
4704
4705 zfCopyToIntTxBuffer(dev, buf, rsn, offset, rsn[1]+2);
4706 zfMemoryCopy(wd->sta.rsnIe, rsn, rsn[1]+2);
4707 offset += (rsn[1]+2);
4708 }
4709 else if ( wd->sta.currentAuthMode == ZM_AUTH_MODE_WPA2 )
4710 {
4711
4712 zfMemoryCopy(rsn+4, wd->sta.rsnIe+4, 4);
4713
4714 zfMemoryCopy(rsn+16, zgWpa2RadiusOui, 4);
4715
4716 if ( wd->sta.wepStatus == ZM_ENCRYPTION_AES )
4717 {
4718
4719 zfMemoryCopy(rsn+10, zgWpa2AesOui, 4);
4720 }
4721
4722 if (( frameType == ZM_WLAN_FRAME_TYPE_REASOCREQ || ( frameType == ZM_WLAN_FRAME_TYPE_ASOCREQ )))
4723 {
4724
4725 if (wd->sta.pmkidInfo.bssidCount != 0) {
4726
4727 rsn[22] = 1;
4728 rsn[23] = 0;
4729
4730
4731
4732
4733 for(i=0; i<wd->sta.pmkidInfo.bssidCount; i++)
4734 {
4735 if ( zfMemoryIsEqual((u8_t*) wd->sta.pmkidInfo.bssidInfo[i].bssid, (u8_t*) wd->sta.bssid, 6) )
4736 {
4737 zfMemoryCopy(rsn+24, wd->sta.pmkidInfo.bssidInfo[i].pmkid, 16);
4738 break;
4739 }
4740 }
4741 rsn[1] += 18;
4742 }
4743
4744 }
4745
4746 zfCopyToIntTxBuffer(dev, buf, rsn, offset, rsn[1]+2);
4747 zfMemoryCopy(wd->sta.rsnIe, rsn, rsn[1]+2);
4748 offset += (rsn[1]+2);
4749 }
4750
4751 return offset;
4752}
4753
4754
4755
4756
4757
4758
4759
4760
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771u16_t zfStaAddIeIbss(zdev_t* dev, zbuf_t* buf, u16_t offset)
4772{
4773 zmw_get_wlan_dev(dev);
4774
4775
4776 zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_IBSS);
4777
4778
4779 zmw_tx_buf_writeb(dev, buf, offset++, 2);
4780
4781
4782 zmw_tx_buf_writeh(dev, buf, offset, wd->sta.atimWindow);
4783 offset += 2;
4784
4785 return offset;
4786}
4787
4788
4789
4790
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
4805
4806
4807u16_t zfStaAddIeWmeInfo(zdev_t* dev, zbuf_t* buf, u16_t offset, u8_t qosInfo)
4808{
4809
4810 zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_WIFI_IE);
4811
4812
4813 zmw_tx_buf_writeb(dev, buf, offset++, 7);
4814
4815
4816 zmw_tx_buf_writeb(dev, buf, offset++, 0x00);
4817 zmw_tx_buf_writeb(dev, buf, offset++, 0x50);
4818 zmw_tx_buf_writeb(dev, buf, offset++, 0xF2);
4819 zmw_tx_buf_writeb(dev, buf, offset++, 0x02);
4820 zmw_tx_buf_writeb(dev, buf, offset++, 0x00);
4821 zmw_tx_buf_writeb(dev, buf, offset++, 0x01);
4822
4823
4824 zmw_tx_buf_writeb(dev, buf, offset++, qosInfo);
4825
4826 return offset;
4827}
4828
4829
4830
4831
4832
4833
4834
4835
4836
4837
4838
4839
4840
4841
4842
4843
4844
4845
4846u16_t zfStaAddIePowerCap(zdev_t* dev, zbuf_t* buf, u16_t offset)
4847{
4848 u8_t MaxTxPower;
4849 u8_t MinTxPower;
4850
4851 zmw_get_wlan_dev(dev);
4852
4853
4854 zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_POWER_CAPABILITY);
4855
4856
4857 zmw_tx_buf_writeb(dev, buf, offset++, 2);
4858
4859 MinTxPower = (u8_t)(zfHpGetMinTxPower(dev)/2);
4860 MaxTxPower = (u8_t)(zfHpGetMaxTxPower(dev)/2);
4861
4862
4863 zmw_tx_buf_writeh(dev, buf, offset++, MinTxPower);
4864
4865
4866 zmw_tx_buf_writeh(dev, buf, offset++, MaxTxPower);
4867
4868 return offset;
4869}
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887u16_t zfStaAddIeSupportCh(zdev_t* dev, zbuf_t* buf, u16_t offset)
4888{
4889
4890 u8_t i;
4891 u16_t count_24G = 0;
4892 u16_t count_5G = 0;
4893 u16_t channelNum;
4894 u8_t length;
4895
4896 zmw_get_wlan_dev(dev);
4897
4898 zmw_declare_for_critical_section();
4899 zmw_enter_critical_section(dev);
4900
4901 for (i = 0; i < wd->regulationTable.allowChannelCnt; i++)
4902 {
4903 if (wd->regulationTable.allowChannel[i].channel < 3000)
4904 {
4905 count_24G++;
4906 }
4907 else
4908 {
4909 count_5G++;
4910 }
4911 }
4912
4913 length = (u8_t)(count_5G * 2 + 2);
4914
4915
4916 zmw_tx_buf_writeb(dev, buf, offset++, ZM_WLAN_EID_SUPPORTED_CHANNELS );
4917
4918
4919 zmw_tx_buf_writeb(dev, buf, offset++, length);
4920
4921
4922
4923 zmw_tx_buf_writeh(dev, buf, offset++, 1);
4924
4925 zmw_tx_buf_writeh(dev, buf, offset++, count_24G);
4926
4927 for (i = 0; i < wd->regulationTable.allowChannelCnt ; i++)
4928 {
4929 if (wd->regulationTable.allowChannel[i].channel > 4000 && wd->regulationTable.allowChannel[i].channel < 5000)
4930 {
4931 channelNum = (wd->regulationTable.allowChannel[i].channel-4000)/5;
4932
4933 zmw_tx_buf_writeh(dev, buf, offset++, channelNum);
4934
4935 zmw_tx_buf_writeh(dev, buf, offset++, 1);
4936 }
4937 else if (wd->regulationTable.allowChannel[i].channel >= 5000)
4938 {
4939 channelNum = (wd->regulationTable.allowChannel[i].channel-5000)/5;
4940
4941 zmw_tx_buf_writeh(dev, buf, offset++, channelNum);
4942
4943 zmw_tx_buf_writeh(dev, buf, offset++, 1);
4944 }
4945 }
4946 zmw_leave_critical_section(dev);
4947
4948 return offset;
4949}
4950
4951void zfStaStartConnectCb(zdev_t* dev)
4952{
4953 zmw_get_wlan_dev(dev);
4954
4955 zfStaStartConnect(dev, wd->sta.bIsSharedKey);
4956}
4957
4958void zfStaStartConnect(zdev_t* dev, u8_t bIsSharedKey)
4959{
4960 u32_t p1, p2;
4961 u8_t newConnState;
4962
4963 zmw_get_wlan_dev(dev);
4964 zmw_declare_for_critical_section();
4965
4966
4967 if ( bIsSharedKey )
4968 {
4969
4970 newConnState = ZM_STA_CONN_STATE_AUTH_SHARE_1;
4971 zm_debug_msg0("ZM_STA_CONN_STATE_AUTH_SHARE_1");
4972 p1 = ZM_AUTH_ALGO_SHARED_KEY;
4973 }
4974 else
4975 {
4976
4977 newConnState = ZM_STA_CONN_STATE_AUTH_OPEN;
4978 zm_debug_msg0("ZM_STA_CONN_STATE_AUTH_OPEN");
4979 if( wd->sta.leapEnabled )
4980 p1 = ZM_AUTH_ALGO_LEAP;
4981 else
4982 p1 = ZM_AUTH_ALGO_OPEN_SYSTEM;
4983 }
4984
4985
4986 p2 = 0x0;
4987
4988 zmw_enter_critical_section(dev);
4989 wd->sta.connectTimer = wd->tick;
4990 wd->sta.connectState = newConnState;
4991 zmw_leave_critical_section(dev);
4992
4993
4994 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_AUTH, wd->sta.bssid, p1, p2, 0);
4995
4996 return;
4997}
4998
4999void zfSendNullData(zdev_t* dev, u8_t type)
5000{
5001 zbuf_t* buf;
5002
5003
5004 u16_t err;
5005 u16_t hlen;
5006 u16_t header[(34+8+1)/2];
5007 u16_t bcastAddr[3] = {0xffff,0xffff,0xffff};
5008 u16_t *dstAddr;
5009
5010 zmw_get_wlan_dev(dev);
5011
5012 if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
5013 {
5014 zm_msg0_mm(ZM_LV_0, "Alloc mm buf Fail!");
5015 return;
5016 }
5017
5018 zfwBufSetSize(dev, buf, 0);
5019
5020
5021
5022 if ( wd->wlanMode == ZM_MODE_IBSS)
5023 {
5024 dstAddr = bcastAddr;
5025 }
5026 else
5027 {
5028 dstAddr = wd->sta.bssid;
5029 }
5030
5031 if (wd->sta.wmeConnected != 0)
5032 {
5033
5034 hlen = zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_QOS_NULL, dstAddr, header, 0, buf, 0, 0);
5035 }
5036 else
5037 {
5038 hlen = zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_NULL, dstAddr, header, 0, buf, 0, 0);
5039 }
5040
5041 if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
5042 {
5043 header[4] |= 0x0100;
5044 }
5045
5046 if ( type == 1 )
5047 {
5048 header[4] |= 0x1000;
5049 }
5050
5051
5052
5053
5054
5055
5056
5057
5058
5059 wd->commTally.txUnicastFrm++;
5060
5061 if ((err = zfHpSend(dev, header, hlen, NULL, 0, NULL, 0, buf, 0,
5062 ZM_INTERNAL_ALLOC_BUF, 0, 0xff)) != ZM_SUCCESS)
5063 {
5064 goto zlError;
5065 }
5066
5067
5068 return;
5069
5070zlError:
5071
5072 zfwBufFree(dev, buf, 0);
5073 return;
5074
5075}
5076
5077void zfSendPSPoll(zdev_t* dev)
5078{
5079 zbuf_t* buf;
5080
5081
5082 u16_t err;
5083 u16_t hlen;
5084 u16_t header[(8+24+1)/2];
5085
5086 zmw_get_wlan_dev(dev);
5087
5088 if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
5089 {
5090 zm_msg0_mm(ZM_LV_0, "Alloc mm buf Fail!");
5091 return;
5092 }
5093
5094 zfwBufSetSize(dev, buf, 0);
5095
5096
5097
5098 zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_PSPOLL, wd->sta.bssid, header, 0, buf, 0, 0);
5099
5100 header[0] = 20;
5101 header[4] |= 0x1000;
5102 header[5] = wd->sta.aid | 0xc000;
5103 hlen = 16 + 8;
5104
5105
5106
5107
5108
5109
5110
5111
5112 if ((err = zfHpSend(dev, header, hlen, NULL, 0, NULL, 0, buf, 0,
5113 ZM_INTERNAL_ALLOC_BUF, 0, 0xff)) != ZM_SUCCESS)
5114 {
5115 goto zlError;
5116 }
5117
5118 return;
5119
5120zlError:
5121
5122 zfwBufFree(dev, buf, 0);
5123 return;
5124
5125}
5126
5127void zfSendBA(zdev_t* dev, u16_t start_seq, u8_t *bitmap)
5128{
5129 zbuf_t* buf;
5130
5131
5132 u16_t err;
5133 u16_t hlen;
5134 u16_t header[(8+24+1)/2];
5135 u16_t i, offset = 0;
5136
5137 zmw_get_wlan_dev(dev);
5138
5139 if ((buf = zfwBufAllocate(dev, 1024)) == NULL)
5140 {
5141 zm_msg0_mm(ZM_LV_0, "Alloc mm buf Fail!");
5142 return;
5143 }
5144
5145 zfwBufSetSize(dev, buf, 12);
5146
5147
5148
5149
5150 zfTxGenMmHeader(dev, ZM_WLAN_FRAME_TYPE_BA, wd->sta.bssid, header, 0, buf, 0, 0);
5151
5152 header[0] = 32;
5153 header[1] = 0x4;
5154
5155
5156 header[2] = (u16_t)(zcRateToPhyCtrl[4] & 0xffff);
5157 header[3] = (u16_t)(zcRateToPhyCtrl[4]>>16) & 0xffff;
5158
5159 hlen = 16 + 8;
5160 offset = 0;
5161 zmw_tx_buf_writeh(dev, buf, offset, 0x05);
5162 offset+=2;
5163 zmw_tx_buf_writeh(dev, buf, offset, start_seq);
5164 offset+=2;
5165
5166 for (i=0; i<8; i++) {
5167 zmw_tx_buf_writeb(dev, buf, offset, bitmap[i]);
5168 offset++;
5169 }
5170
5171 if ((err = zfHpSend(dev, header, hlen, NULL, 0, NULL, 0, buf, 0,
5172 ZM_INTERNAL_ALLOC_BUF, 0, 0xff)) != ZM_SUCCESS)
5173 {
5174 goto zlError;
5175 }
5176
5177 return;
5178
5179zlError:
5180
5181 zfwBufFree(dev, buf, 0);
5182 return;
5183
5184}
5185
5186void zfStaGetTxRate(zdev_t* dev, u16_t* macAddr, u32_t* phyCtrl,
5187 u16_t* rcProbingFlag)
5188{
5189 u8_t addr[6], i;
5190 u8_t rate;
5191 zmw_get_wlan_dev(dev);
5192 zmw_declare_for_critical_section();
5193
5194 ZM_MAC_WORD_TO_BYTE(macAddr, addr);
5195 *phyCtrl = 0;
5196
5197 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
5198 {
5199 zmw_enter_critical_section(dev);
5200 rate = (u8_t)zfRateCtrlGetTxRate(dev, &wd->sta.oppositeInfo[0].rcCell, rcProbingFlag);
5201
5202
5203
5204 *phyCtrl = zcRateToPhyCtrl[rate];
5205 zmw_leave_critical_section(dev);
5206 }
5207 else
5208 {
5209 zmw_enter_critical_section(dev);
5210 for(i=0; i<wd->sta.oppositeCount; i++)
5211 {
5212 if ( addr[0] && 0x01 == 1 )
5213
5214 {
5215
5216 rate = wd->sta.oppositeInfo[i].rcCell.operationRateSet[0];
5217 *phyCtrl = zcRateToPhyCtrl[rate];
5218 break;
5219 }
5220 else if ( zfMemoryIsEqual(addr, wd->sta.oppositeInfo[i].macAddr, 6) )
5221 {
5222 rate = (u8_t)zfRateCtrlGetTxRate(dev, &wd->sta.oppositeInfo[i].rcCell, rcProbingFlag);
5223 *phyCtrl = zcRateToPhyCtrl[rate];
5224 break;
5225 }
5226 }
5227 zmw_leave_critical_section(dev);
5228 }
5229
5230 return;
5231}
5232
5233struct zsMicVar* zfStaGetRxMicKey(zdev_t* dev, zbuf_t* buf)
5234{
5235 u8_t keyIndex;
5236 u8_t da0;
5237
5238 zmw_get_wlan_dev(dev);
5239
5240
5241 if ( ((wd->sta.encryMode != ZM_TKIP)&&(wd->sta.encryMode != ZM_AES))||
5242 (wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK) )
5243 {
5244 return NULL;
5245 }
5246
5247 da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5248
5249 if ((zmw_rx_buf_readb(dev, buf, 0) & 0x80) == 0x80)
5250 keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+5);
5251 else
5252 keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+3);
5253 keyIndex = (keyIndex & 0xc0) >> 6;
5254
5255 return (&wd->sta.rxMicKey[keyIndex]);
5256}
5257
5258struct zsMicVar* zfStaGetTxMicKey(zdev_t* dev, zbuf_t* buf)
5259{
5260 zmw_get_wlan_dev(dev);
5261
5262
5263
5264
5265 if ( (wd->sta.encryMode != ZM_TKIP) || (wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK) )
5266 {
5267 return NULL;
5268 }
5269
5270 return (&wd->sta.txMicKey);
5271}
5272
5273u16_t zfStaRxValidateFrame(zdev_t* dev, zbuf_t* buf)
5274{
5275 u8_t frameType, frameCtrl;
5276 u8_t da0;
5277
5278 u16_t ret;
5279 u16_t i;
5280
5281
5282 zmw_get_wlan_dev(dev);
5283
5284 frameType = zmw_rx_buf_readb(dev, buf, 0);
5285 da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5286
5287
5288 if ( (!zfStaIsConnected(dev))&&((frameType & 0xf) == ZM_WLAN_DATA_FRAME) )
5289 {
5290 return ZM_ERR_DATA_BEFORE_CONNECTED;
5291 }
5292
5293
5294 if ( (zfStaIsConnected(dev))&&((frameType & 0xf) == ZM_WLAN_DATA_FRAME) )
5295 {
5296
5297 if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
5298 {
5299
5300 u16_t mac[3];
5301 mac[0] = zmw_cpu_to_le16(wd->sta.bssid[0]);
5302 mac[1] = zmw_cpu_to_le16(wd->sta.bssid[1]);
5303 mac[2] = zmw_cpu_to_le16(wd->sta.bssid[2]);
5304 if ( !zfRxBufferEqualToStr(dev, buf, (u8_t *)mac,
5305 ZM_WLAN_HEADER_A2_OFFSET, 6) )
5306 {
5307
5308
5309#if 0
5310
5311 if (( da0 & 0x01 ) == 0)
5312 {
5313 for (i=0; i<3; i++)
5314 {
5315 sa[i] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET+(i*2));
5316 }
5317
5318 if (( sa0 & 0x01 ) == 0)
5319 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, sa, 7, 0, 0);
5320 }
5321#endif
5322 return ZM_ERR_DATA_BSSID_NOT_MATCHED;
5323 }
5324 }
5325 else if ( wd->wlanMode == ZM_MODE_IBSS )
5326 {
5327
5328 u16_t mac[3];
5329 mac[0] = zmw_cpu_to_le16(wd->sta.bssid[0]);
5330 mac[1] = zmw_cpu_to_le16(wd->sta.bssid[1]);
5331 mac[2] = zmw_cpu_to_le16(wd->sta.bssid[2]);
5332 if ( !zfRxBufferEqualToStr(dev, buf, (u8_t *)mac,
5333 ZM_WLAN_HEADER_A3_OFFSET, 6) )
5334 {
5335 return ZM_ERR_DATA_BSSID_NOT_MATCHED;
5336 }
5337 }
5338
5339 frameCtrl = zmw_rx_buf_readb(dev, buf, 1);
5340
5341
5342 if ( wd->sta.dropUnencryptedPkts &&
5343 (wd->sta.wepStatus != ZM_ENCRYPTION_WEP_DISABLED )&&
5344 ( !(frameCtrl & ZM_BIT_6) ) )
5345 {
5346
5347 #if 1
5348 ret = ZM_ERR_DATA_NOT_ENCRYPTED;
5349 if ( wd->sta.pStaRxSecurityCheckCb != NULL )
5350 {
5351 ret = wd->sta.pStaRxSecurityCheckCb(dev, buf);
5352 }
5353 else
5354 {
5355 ret = ZM_ERR_DATA_NOT_ENCRYPTED;
5356 }
5357 if (ret == ZM_ERR_DATA_NOT_ENCRYPTED)
5358 {
5359 wd->commTally.swRxDropUnencryptedCount++;
5360 }
5361 return ret;
5362 #else
5363 if ( (wd->sta.wepStatus != ZM_ENCRYPTION_TKIP)&&
5364 (wd->sta.wepStatus != ZM_ENCRYPTION_AES) )
5365 {
5366 return ZM_ERR_DATA_NOT_ENCRYPTED;
5367 }
5368 #endif
5369 }
5370 }
5371
5372 return ZM_SUCCESS;
5373}
5374
5375void zfStaMicFailureHandling(zdev_t* dev, zbuf_t* buf)
5376{
5377 u8_t da0;
5378 u8_t micNotify = 1;
5379
5380 zmw_get_wlan_dev(dev);
5381
5382 zmw_declare_for_critical_section();
5383
5384 if ( wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK )
5385 {
5386 return;
5387 }
5388
5389 zmw_enter_critical_section(dev);
5390
5391 wd->sta.cmMicFailureCount++;
5392
5393 if ( wd->sta.cmMicFailureCount == 1 )
5394 {
5395 zm_debug_msg0("get the first MIC failure");
5396
5397
5398
5399
5400 zfTimerSchedule(dev, ZM_EVENT_CM_TIMER, ZM_TICK_CM_TIMEOUT - ZM_TICK_CM_TIMEOUT_OFFSET);
5401 }
5402 else if ( wd->sta.cmMicFailureCount == 2 )
5403 {
5404 zm_debug_msg0("get the second MIC failure");
5405
5406 wd->sta.cmDisallowSsidLength = wd->sta.ssidLen;
5407 zfMemoryCopy(wd->sta.cmDisallowSsid, wd->sta.ssid, wd->sta.ssidLen);
5408
5409 zfTimerCancel(dev, ZM_EVENT_CM_TIMER);
5410
5411
5412
5413
5414 zfTimerSchedule(dev, ZM_EVENT_CM_DISCONNECT, ZM_TICK_CM_DISCONNECT - ZM_TICK_CM_DISCONNECT_OFFSET);
5415 }
5416 else
5417 {
5418 micNotify = 0;
5419 }
5420
5421 zmw_leave_critical_section(dev);
5422
5423 if (micNotify == 1)
5424 {
5425 da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5426 if ( da0 & 0x01 )
5427 {
5428 if (wd->zfcbMicFailureNotify != NULL)
5429 {
5430 wd->zfcbMicFailureNotify(dev, wd->sta.bssid, ZM_MIC_GROUP_ERROR);
5431 }
5432 }
5433 else
5434 {
5435 if (wd->zfcbMicFailureNotify != NULL)
5436 {
5437 wd->zfcbMicFailureNotify(dev, wd->sta.bssid, ZM_MIC_PAIRWISE_ERROR);
5438 }
5439 }
5440 }
5441}
5442
5443
5444u8_t zfStaBlockWlanScan(zdev_t* dev)
5445{
5446 u8_t ret=FALSE;
5447
5448 zmw_get_wlan_dev(dev);
5449
5450 if ( wd->sta.bChannelScan )
5451 {
5452 return TRUE;
5453 }
5454
5455 return ret;
5456}
5457
5458void zfStaResetStatus(zdev_t* dev, u8_t bInit)
5459{
5460 u8_t i;
5461
5462 zmw_get_wlan_dev(dev);
5463
5464 zfHpDisableBeacon(dev);
5465
5466 wd->dtim = 1;
5467 wd->sta.capability[0] = 0x01;
5468 wd->sta.capability[1] = 0x00;
5469
5470 if (wd->sta.DFSEnable || wd->sta.TPCEnable)
5471 wd->sta.capability[1] |= ZM_BIT_0;
5472
5473
5474 for(i=0; i<wd->sta.ibssPSDataCount; i++)
5475 {
5476 zfwBufFree(dev, wd->sta.ibssPSDataQueue[i], 0);
5477 }
5478
5479 for(i=0; i<wd->sta.staPSDataCount; i++)
5480 {
5481 zfwBufFree(dev, wd->sta.staPSDataQueue[i], 0);
5482 }
5483
5484 wd->sta.ibssPSDataCount = 0;
5485 wd->sta.staPSDataCount = 0;
5486 zfZeroMemory((u8_t*) &wd->sta.staPSList, sizeof(struct zsStaPSList));
5487
5488 wd->sta.wmeConnected = 0;
5489 wd->sta.psMgr.tempWakeUp = 0;
5490 wd->sta.qosInfo = 0;
5491 zfQueueFlush(dev, wd->sta.uapsdQ);
5492
5493 return;
5494
5495}
5496
5497void zfStaIbssMonitoring(zdev_t* dev, u8_t reset)
5498{
5499 u16_t i;
5500 u16_t oppositeCount;
5501 struct zsPartnerNotifyEvent event;
5502
5503 zmw_get_wlan_dev(dev);
5504
5505 zmw_declare_for_critical_section();
5506
5507
5508
5509 zmw_enter_critical_section(dev);
5510
5511 if ( wd->sta.oppositeCount == 0 )
5512 {
5513 goto done;
5514 }
5515
5516 if ( wd->sta.bChannelScan )
5517 {
5518 goto done;
5519 }
5520
5521 oppositeCount = wd->sta.oppositeCount;
5522
5523 for(i=0; i < ZM_MAX_OPPOSITE_COUNT; i++)
5524 {
5525 if ( oppositeCount == 0 )
5526 {
5527 break;
5528 }
5529
5530 if ( reset )
5531 {
5532 wd->sta.oppositeInfo[i].valid = 0;
5533 }
5534
5535 if ( wd->sta.oppositeInfo[i].valid == 0 )
5536 {
5537 continue;
5538 }
5539
5540 oppositeCount--;
5541
5542 if ( wd->sta.oppositeInfo[i].aliveCounter )
5543 {
5544 zm_debug_msg1("Setting alive to ", wd->sta.oppositeInfo[i].aliveCounter);
5545
5546 zmw_leave_critical_section(dev);
5547
5548 if ( wd->sta.oppositeInfo[i].aliveCounter != ZM_IBSS_PEER_ALIVE_COUNTER )
5549 {
5550 zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_PROBEREQ,
5551 (u16_t*)wd->sta.oppositeInfo[i].macAddr, 1, 0, 0);
5552 }
5553
5554 zmw_enter_critical_section(dev);
5555 wd->sta.oppositeInfo[i].aliveCounter--;
5556 }
5557 else
5558 {
5559 zm_debug_msg0("zfStaIbssMonitoring remove the peer station");
5560 zfMemoryCopy(event.bssid, (u8_t *)(wd->sta.bssid), 6);
5561 zfMemoryCopy(event.peerMacAddr, wd->sta.oppositeInfo[i].macAddr, 6);
5562
5563 wd->sta.oppositeInfo[i].valid = 0;
5564 wd->sta.oppositeCount--;
5565 if (wd->zfcbIbssPartnerNotify != NULL)
5566 {
5567 zmw_leave_critical_section(dev);
5568 wd->zfcbIbssPartnerNotify(dev, 0, &event);
5569 zmw_enter_critical_section(dev);
5570 }
5571 }
5572 }
5573
5574done:
5575 if ( reset == 0 )
5576 {
5577 zfTimerSchedule(dev, ZM_EVENT_IBSS_MONITOR, ZM_TICK_IBSS_MONITOR);
5578 }
5579
5580 zmw_leave_critical_section(dev);
5581}
5582
5583void zfInitPartnerNotifyEvent(zdev_t* dev, zbuf_t* buf, struct zsPartnerNotifyEvent *event)
5584{
5585 u16_t *peerMacAddr;
5586
5587 zmw_get_wlan_dev(dev);
5588
5589 peerMacAddr = (u16_t *)event->peerMacAddr;
5590
5591 zfMemoryCopy(event->bssid, (u8_t *)(wd->sta.bssid), 6);
5592 peerMacAddr[0] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET);
5593 peerMacAddr[1] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET + 2);
5594 peerMacAddr[2] = zmw_rx_buf_readh(dev, buf, ZM_WLAN_HEADER_A2_OFFSET + 4);
5595}
5596
5597void zfStaInitOppositeInfo(zdev_t* dev)
5598{
5599 int i;
5600
5601 zmw_get_wlan_dev(dev);
5602
5603 for(i=0; i<ZM_MAX_OPPOSITE_COUNT; i++)
5604 {
5605 wd->sta.oppositeInfo[i].valid = 0;
5606 wd->sta.oppositeInfo[i].aliveCounter = ZM_IBSS_PEER_ALIVE_COUNTER;
5607 }
5608}
5609#ifdef ZM_ENABLE_CENC
5610u16_t zfStaAddIeCenc(zdev_t* dev, zbuf_t* buf, u16_t offset)
5611{
5612 zmw_get_wlan_dev(dev);
5613
5614 if (wd->sta.cencIe[1] != 0)
5615 {
5616 zfCopyToIntTxBuffer(dev, buf, wd->sta.cencIe, offset, wd->sta.cencIe[1]+2);
5617 offset += (wd->sta.cencIe[1]+2);
5618 }
5619 return offset;
5620}
5621#endif
5622u16_t zfStaProcessAction(zdev_t* dev, zbuf_t* buf)
5623{
5624 u8_t category, actionDetails;
5625 zmw_get_wlan_dev(dev);
5626
5627 category = zmw_rx_buf_readb(dev, buf, 24);
5628 actionDetails = zmw_rx_buf_readb(dev, buf, 25);
5629 switch (category)
5630 {
5631 case 0:
5632 switch(actionDetails)
5633 {
5634 case 0:
5635 break;
5636 case 1:
5637
5638 break;
5639 case 2:
5640
5641
5642 break;
5643 case 3:
5644
5645
5646 break;
5647 case 4:
5648 if (wd->sta.DFSEnable)
5649 zfStaUpdateDot11HDFS(dev, buf);
5650 break;
5651 default:
5652 zm_debug_msg1("Action Frame contain not support action field ", actionDetails);
5653 break;
5654 }
5655 break;
5656 case ZM_WLAN_BLOCK_ACK_ACTION_FRAME:
5657 zfAggBlockAckActionFrame(dev, buf);
5658 break;
5659 case 17:
5660 break;
5661 }
5662
5663 return 0;
5664}
5665
5666
5667
5668void zfReWriteBeaconStartAddress(zdev_t* dev)
5669{
5670 zmw_get_wlan_dev(dev);
5671
5672 zmw_declare_for_critical_section();
5673
5674 zmw_enter_critical_section(dev);
5675 wd->tickIbssSendBeacon++;
5676 zmw_leave_critical_section(dev);
5677
5678 if ( wd->tickIbssSendBeacon == 40 )
5679 {
5680
5681 zfHpEnableBeacon(dev, ZM_MODE_IBSS, wd->beaconInterval, wd->dtim, (u8_t)wd->sta.atimWindow);
5682 zmw_enter_critical_section(dev);
5683 wd->tickIbssSendBeacon = 0;
5684 zmw_leave_critical_section(dev);
5685 }
5686}
5687
5688struct zsTkipSeed* zfStaGetRxSeed(zdev_t* dev, zbuf_t* buf)
5689{
5690 u8_t keyIndex;
5691 u8_t da0;
5692
5693 zmw_get_wlan_dev(dev);
5694
5695
5696 if ( ((wd->sta.encryMode != ZM_TKIP)&&(wd->sta.encryMode != ZM_AES))||
5697 (wd->sta.wpaState < ZM_STA_WPA_STATE_PK_OK) )
5698 {
5699 return NULL;
5700 }
5701
5702 da0 = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_A1_OFFSET);
5703
5704 if ((zmw_rx_buf_readb(dev, buf, 0) & 0x80) == 0x80)
5705 keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+5);
5706 else
5707 keyIndex = zmw_rx_buf_readb(dev, buf, ZM_WLAN_HEADER_IV_OFFSET+3);
5708 keyIndex = (keyIndex & 0xc0) >> 6;
5709
5710 return (&wd->sta.rxSeed[keyIndex]);
5711}
5712
5713void zfStaEnableSWEncryption(zdev_t *dev, u8_t value)
5714{
5715 zmw_get_wlan_dev(dev);
5716
5717 wd->sta.SWEncryptEnable = value;
5718 zfHpSWDecrypt(dev, 1);
5719 zfHpSWEncrypt(dev, 1);
5720}
5721
5722void zfStaDisableSWEncryption(zdev_t *dev)
5723{
5724 zmw_get_wlan_dev(dev);
5725
5726 wd->sta.SWEncryptEnable = 0;
5727 zfHpSWDecrypt(dev, 0);
5728 zfHpSWEncrypt(dev, 0);
5729}
5730
5731u16_t zfComputeBssInfoWeightValue(zdev_t *dev, u8_t isBMode, u8_t isHT, u8_t isHT40, u8_t signalStrength)
5732{
5733 u8_t weightOfB = 0;
5734 u8_t weightOfAGBelowThr = 0;
5735 u8_t weightOfAGUpThr = 15;
5736 u8_t weightOfN20BelowThr = 15;
5737 u8_t weightOfN20UpThr = 30;
5738 u8_t weightOfN40BelowThr = 16;
5739 u8_t weightOfN40UpThr = 32;
5740
5741 zmw_get_wlan_dev(dev);
5742
5743 if( isBMode == 0 )
5744 return (signalStrength + weightOfB);
5745 else
5746 {
5747 if( isHT == 0 && isHT40 == 0 )
5748 {
5749 if( signalStrength < 18 )
5750 return signalStrength + weightOfAGBelowThr;
5751 else
5752 return (signalStrength + weightOfAGUpThr);
5753 }
5754 else if( isHT == 1 && isHT40 == 0 )
5755 {
5756 if( signalStrength < 23 )
5757 return (signalStrength + weightOfN20BelowThr);
5758 else
5759 return (signalStrength + weightOfN20UpThr);
5760 }
5761 else
5762 {
5763 if( signalStrength < 16 )
5764 return (signalStrength + weightOfN40BelowThr);
5765 else
5766 return (signalStrength + weightOfN40UpThr);
5767 }
5768 }
5769}
5770
5771u16_t zfStaAddIbssAdditionalIE(zdev_t* dev, zbuf_t* buf, u16_t offset)
5772{
5773 u16_t i;
5774
5775 zmw_get_wlan_dev(dev);
5776
5777 for (i=0; i<wd->sta.ibssAdditionalIESize; i++)
5778 {
5779 zmw_tx_buf_writeb(dev, buf, offset++, wd->sta.ibssAdditionalIE[i]);
5780 }
5781
5782 return offset;
5783}
5784