1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64#include "tmacro.h"
65#include "desc.h"
66#include "device.h"
67#include "card.h"
68#include "80211hdr.h"
69#include "80211mgr.h"
70#include "wmgr.h"
71#include "wcmd.h"
72#include "mac.h"
73#include "bssdb.h"
74#include "power.h"
75#include "datarate.h"
76#include "baseband.h"
77#include "rxtx.h"
78#include "wpa.h"
79#include "rf.h"
80#include "iowpa.h"
81
82#define PLICE_DEBUG
83
84
85
86
87
88
89
90
91static int msglevel =MSG_LEVEL_INFO;
92
93
94
95
96static BOOL ChannelExceedZoneType(
97 IN PSDevice pDevice,
98 IN BYTE byCurrChannel
99 );
100
101
102static
103PSTxMgmtPacket
104s_MgrMakeAssocRequest(
105 IN PSDevice pDevice,
106 IN PSMgmtObject pMgmt,
107 IN PBYTE pDAddr,
108 IN WORD wCurrCapInfo,
109 IN WORD wListenInterval,
110 IN PWLAN_IE_SSID pCurrSSID,
111 IN PWLAN_IE_SUPP_RATES pCurrRates,
112 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
113 );
114
115static
116VOID
117s_vMgrRxAssocRequest(
118 IN PSDevice pDevice,
119 IN PSMgmtObject pMgmt,
120 IN PSRxMgmtPacket pRxPacket,
121 IN UINT uNodeIndex
122 );
123
124static
125PSTxMgmtPacket
126s_MgrMakeReAssocRequest(
127 IN PSDevice pDevice,
128 IN PSMgmtObject pMgmt,
129 IN PBYTE pDAddr,
130 IN WORD wCurrCapInfo,
131 IN WORD wListenInterval,
132 IN PWLAN_IE_SSID pCurrSSID,
133 IN PWLAN_IE_SUPP_RATES pCurrRates,
134 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
135 );
136
137static
138VOID
139s_vMgrRxAssocResponse(
140 IN PSDevice pDevice,
141 IN PSMgmtObject pMgmt,
142 IN PSRxMgmtPacket pRxPacket,
143 IN BOOL bReAssocType
144 );
145
146static
147VOID
148s_vMgrRxDisassociation(
149 IN PSDevice pDevice,
150 IN PSMgmtObject pMgmt,
151 IN PSRxMgmtPacket pRxPacket
152 );
153
154
155static
156VOID
157s_vMgrRxAuthenSequence_1(
158 IN PSDevice pDevice,
159 IN PSMgmtObject pMgmt,
160 IN PWLAN_FR_AUTHEN pFrame
161 );
162
163static
164VOID
165s_vMgrRxAuthenSequence_2(
166 IN PSDevice pDevice,
167 IN PSMgmtObject pMgmt,
168 IN PWLAN_FR_AUTHEN pFrame
169 );
170
171static
172VOID
173s_vMgrRxAuthenSequence_3(
174 IN PSDevice pDevice,
175 IN PSMgmtObject pMgmt,
176 IN PWLAN_FR_AUTHEN pFrame
177 );
178
179static
180VOID
181s_vMgrRxAuthenSequence_4(
182 IN PSDevice pDevice,
183 IN PSMgmtObject pMgmt,
184 IN PWLAN_FR_AUTHEN pFrame
185 );
186
187static
188VOID
189s_vMgrRxAuthentication(
190 IN PSDevice pDevice,
191 IN PSMgmtObject pMgmt,
192 IN PSRxMgmtPacket pRxPacket
193 );
194
195static
196VOID
197s_vMgrRxDeauthentication(
198 IN PSDevice pDevice,
199 IN PSMgmtObject pMgmt,
200 IN PSRxMgmtPacket pRxPacket
201 );
202
203
204
205static
206VOID
207s_vMgrRxProbeRequest(
208 IN PSDevice pDevice,
209 IN PSMgmtObject pMgmt,
210 IN PSRxMgmtPacket pRxPacket
211 );
212
213static
214VOID
215s_vMgrRxProbeResponse(
216 IN PSDevice pDevice,
217 IN PSMgmtObject pMgmt,
218 IN PSRxMgmtPacket pRxPacket
219 );
220
221
222static
223VOID
224s_vMgrRxBeacon(
225 IN PSDevice pDevice,
226 IN PSMgmtObject pMgmt,
227 IN PSRxMgmtPacket pRxPacket,
228 IN BOOL bInScan
229 );
230
231static
232VOID
233s_vMgrFormatTIM(
234 IN PSMgmtObject pMgmt,
235 IN PWLAN_IE_TIM pTIM
236 );
237
238static
239PSTxMgmtPacket
240s_MgrMakeBeacon(
241 IN PSDevice pDevice,
242 IN PSMgmtObject pMgmt,
243 IN WORD wCurrCapInfo,
244 IN WORD wCurrBeaconPeriod,
245 IN UINT uCurrChannel,
246 IN WORD wCurrATIMWinodw,
247 IN PWLAN_IE_SSID pCurrSSID,
248 IN PBYTE pCurrBSSID,
249 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
250 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
251 );
252
253
254
255static
256PSTxMgmtPacket
257s_MgrMakeAssocResponse(
258 IN PSDevice pDevice,
259 IN PSMgmtObject pMgmt,
260 IN WORD wCurrCapInfo,
261 IN WORD wAssocStatus,
262 IN WORD wAssocAID,
263 IN PBYTE pDstAddr,
264 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
265 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
266 );
267
268
269static
270PSTxMgmtPacket
271s_MgrMakeReAssocResponse(
272 IN PSDevice pDevice,
273 IN PSMgmtObject pMgmt,
274 IN WORD wCurrCapInfo,
275 IN WORD wAssocStatus,
276 IN WORD wAssocAID,
277 IN PBYTE pDstAddr,
278 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
279 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
280 );
281
282
283static
284PSTxMgmtPacket
285s_MgrMakeProbeResponse(
286 IN PSDevice pDevice,
287 IN PSMgmtObject pMgmt,
288 IN WORD wCurrCapInfo,
289 IN WORD wCurrBeaconPeriod,
290 IN UINT uCurrChannel,
291 IN WORD wCurrATIMWinodw,
292 IN PBYTE pDstAddr,
293 IN PWLAN_IE_SSID pCurrSSID,
294 IN PBYTE pCurrBSSID,
295 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
296 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates,
297 IN BYTE byPHYType
298 );
299
300
301static
302VOID
303s_vMgrLogStatus(
304 IN PSMgmtObject pMgmt,
305 IN WORD wStatus
306 );
307
308
309static
310VOID
311s_vMgrSynchBSS (
312 IN PSDevice pDevice,
313 IN UINT uBSSMode,
314 IN PKnownBSS pCurr,
315 OUT PCMD_STATUS pStatus
316 );
317
318
319static BOOL
320s_bCipherMatch (
321 IN PKnownBSS pBSSNode,
322 IN NDIS_802_11_ENCRYPTION_STATUS EncStatus,
323 OUT PBYTE pbyCCSPK,
324 OUT PBYTE pbyCCSGK
325 );
326
327 static VOID Encyption_Rebuild(
328 IN PSDevice pDevice,
329 IN PKnownBSS pCurr
330 );
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350VOID
351vMgrObjectInit(
352 IN HANDLE hDeviceContext
353 )
354{
355 PSDevice pDevice = (PSDevice)hDeviceContext;
356 PSMgmtObject pMgmt = pDevice->pMgmt;
357 int ii;
358
359
360 pMgmt->pbyPSPacketPool = &pMgmt->byPSPacketPool[0];
361 pMgmt->pbyMgmtPacketPool = &pMgmt->byMgmtPacketPool[0];
362 pMgmt->uCurrChannel = pDevice->uChannel;
363 for(ii=0;ii<WLAN_BSSID_LEN;ii++) {
364 pMgmt->abyDesireBSSID[ii] = 0xFF;
365 }
366 pMgmt->sAssocInfo.AssocInfo.Length = sizeof(NDIS_802_11_ASSOCIATION_INFORMATION);
367
368 pMgmt->byCSSPK = KEY_CTL_NONE;
369 pMgmt->byCSSGK = KEY_CTL_NONE;
370 pMgmt->wIBSSBeaconPeriod = DEFAULT_IBSS_BI;
371 BSSvClearBSSList((HANDLE)pDevice, FALSE);
372
373 return;
374}
375
376
377
378
379
380
381
382
383
384
385
386void
387vMgrTimerInit(
388 IN HANDLE hDeviceContext
389 )
390{
391 PSDevice pDevice = (PSDevice)hDeviceContext;
392 PSMgmtObject pMgmt = pDevice->pMgmt;
393
394
395 init_timer(&pMgmt->sTimerSecondCallback);
396 pMgmt->sTimerSecondCallback.data = (ULONG)pDevice;
397 pMgmt->sTimerSecondCallback.function = (TimerFunction)BSSvSecondCallBack;
398 pMgmt->sTimerSecondCallback.expires = RUN_AT(HZ);
399
400 init_timer(&pDevice->sTimerCommand);
401 pDevice->sTimerCommand.data = (ULONG)pDevice;
402 pDevice->sTimerCommand.function = (TimerFunction)vCommandTimer;
403 pDevice->sTimerCommand.expires = RUN_AT(HZ);
404
405 #ifdef TxInSleep
406 init_timer(&pDevice->sTimerTxData);
407 pDevice->sTimerTxData.data = (ULONG)pDevice;
408 pDevice->sTimerTxData.function = (TimerFunction)BSSvSecondTxData;
409 pDevice->sTimerTxData.expires = RUN_AT(10*HZ);
410 pDevice->fTxDataInSleep = FALSE;
411 pDevice->IsTxDataTrigger = FALSE;
412 pDevice->nTxDataTimeCout = 0;
413 #endif
414
415 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
416 pDevice->uCmdDequeueIdx = 0;
417 pDevice->uCmdEnqueueIdx = 0;
418
419 return;
420}
421
422
423
424
425
426
427
428
429
430
431
432
433
434VOID
435vMgrObjectReset(
436 IN HANDLE hDeviceContext
437 )
438{
439 PSDevice pDevice = (PSDevice)hDeviceContext;
440 PSMgmtObject pMgmt = pDevice->pMgmt;
441
442 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
443 pMgmt->eCurrState = WMAC_STATE_IDLE;
444 pDevice->bEnablePSMode = FALSE;
445
446
447 return;
448}
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463VOID
464vMgrAssocBeginSta(
465 IN HANDLE hDeviceContext,
466 IN PSMgmtObject pMgmt,
467 OUT PCMD_STATUS pStatus
468 )
469{
470 PSDevice pDevice = (PSDevice)hDeviceContext;
471 PSTxMgmtPacket pTxPacket;
472
473
474 pMgmt->wCurrCapInfo = 0;
475 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_ESS(1);
476 if (pDevice->bEncryptionEnable) {
477 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_PRIVACY(1);
478 }
479
480
481
482
483 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
484 if (pMgmt->wListenInterval == 0)
485 pMgmt->wListenInterval = 1;
486
487
488 if (pMgmt->eCurrentPHYMode == PHY_TYPE_11G) {
489 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
490 if (CARDbIsShorSlotTime(pMgmt->pAdapter) == TRUE) {
491 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
492 }
493 } else if (pMgmt->eCurrentPHYMode == PHY_TYPE_11B) {
494 if (CARDbIsShortPreamble(pMgmt->pAdapter) == TRUE) {
495 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
496 }
497 }
498 if (pMgmt->b11hEnable == TRUE)
499 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SPECTRUMMNG(1);
500
501
502 pTxPacket = s_MgrMakeAssocRequest
503 (
504 pDevice,
505 pMgmt,
506 pMgmt->abyCurrBSSID,
507 pMgmt->wCurrCapInfo,
508 pMgmt->wListenInterval,
509 (PWLAN_IE_SSID)pMgmt->abyCurrSSID,
510 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
511 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
512 );
513
514 if (pTxPacket != NULL ){
515
516 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
517 if (*pStatus == CMD_STATUS_PENDING) {
518 pMgmt->eCurrState = WMAC_STATE_ASSOCPENDING;
519 *pStatus = CMD_STATUS_SUCCESS;
520 }
521 }
522 else
523 *pStatus = CMD_STATUS_RESOURCES;
524
525 return ;
526}
527
528
529
530
531
532
533
534
535
536
537
538
539VOID
540vMgrReAssocBeginSta(
541 IN HANDLE hDeviceContext,
542 IN PSMgmtObject pMgmt,
543 OUT PCMD_STATUS pStatus
544 )
545{
546 PSDevice pDevice = (PSDevice)hDeviceContext;
547 PSTxMgmtPacket pTxPacket;
548
549
550
551 pMgmt->wCurrCapInfo = 0;
552 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_ESS(1);
553 if (pDevice->bEncryptionEnable) {
554 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_PRIVACY(1);
555 }
556
557
558
559
560 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
561
562 if (pMgmt->wListenInterval == 0)
563 pMgmt->wListenInterval = 1;
564
565
566
567 if (pMgmt->eCurrentPHYMode == PHY_TYPE_11G) {
568 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
569 if (CARDbIsShorSlotTime(pMgmt->pAdapter) == TRUE) {
570 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
571 }
572 } else if (pMgmt->eCurrentPHYMode == PHY_TYPE_11B) {
573 if (CARDbIsShortPreamble(pMgmt->pAdapter) == TRUE) {
574 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
575 }
576 }
577 if (pMgmt->b11hEnable == TRUE)
578 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SPECTRUMMNG(1);
579
580
581 pTxPacket = s_MgrMakeReAssocRequest
582 (
583 pDevice,
584 pMgmt,
585 pMgmt->abyCurrBSSID,
586 pMgmt->wCurrCapInfo,
587 pMgmt->wListenInterval,
588 (PWLAN_IE_SSID)pMgmt->abyCurrSSID,
589 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
590 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
591 );
592
593 if (pTxPacket != NULL ){
594
595 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
596 if (*pStatus != CMD_STATUS_PENDING) {
597 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Reassociation tx failed.\n");
598 }
599 else {
600 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Reassociation tx sending.\n");
601 }
602 }
603
604
605 return ;
606}
607
608
609
610
611
612
613
614
615
616
617
618VOID
619vMgrDisassocBeginSta(
620 IN HANDLE hDeviceContext,
621 IN PSMgmtObject pMgmt,
622 IN PBYTE abyDestAddress,
623 IN WORD wReason,
624 OUT PCMD_STATUS pStatus
625 )
626{
627 PSDevice pDevice = (PSDevice)hDeviceContext;
628 PSTxMgmtPacket pTxPacket = NULL;
629 WLAN_FR_DISASSOC sFrame;
630
631 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
632 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_DISASSOC_FR_MAXLEN);
633 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
634
635
636 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
637 sFrame.len = WLAN_DISASSOC_FR_MAXLEN;
638
639
640 vMgrEncodeDisassociation(&sFrame);
641
642
643 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
644 (
645 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
646 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_DISASSOC)
647 ));
648
649 memcpy( sFrame.pHdr->sA3.abyAddr1, abyDestAddress, WLAN_ADDR_LEN);
650 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
651 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
652
653
654 *(sFrame.pwReason) = cpu_to_le16(wReason);
655 pTxPacket->cbMPDULen = sFrame.len;
656 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
657
658
659 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
660 if (*pStatus == CMD_STATUS_PENDING) {
661 pMgmt->eCurrState = WMAC_STATE_IDLE;
662 *pStatus = CMD_STATUS_SUCCESS;
663 };
664
665 return;
666}
667
668
669
670
671
672
673
674
675
676
677
678
679
680static
681VOID
682s_vMgrRxAssocRequest(
683 IN PSDevice pDevice,
684 IN PSMgmtObject pMgmt,
685 IN PSRxMgmtPacket pRxPacket,
686 IN UINT uNodeIndex
687 )
688{
689 WLAN_FR_ASSOCREQ sFrame;
690 CMD_STATUS Status;
691 PSTxMgmtPacket pTxPacket;
692 WORD wAssocStatus = 0;
693 WORD wAssocAID = 0;
694 UINT uRateLen = WLAN_RATES_MAXLEN;
695 BYTE abyCurrSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
696 BYTE abyCurrExtSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
697
698
699 if (pMgmt->eCurrMode != WMAC_MODE_ESS_AP)
700 return;
701
702 if (!uNodeIndex)
703 return;
704
705
706
707 memset(&sFrame, 0, sizeof(WLAN_FR_ASSOCREQ));
708 memset(abyCurrSuppRates, 0, WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
709 memset(abyCurrExtSuppRates, 0, WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
710 sFrame.len = pRxPacket->cbMPDULen;
711 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
712
713 vMgrDecodeAssocRequest(&sFrame);
714
715 if (pMgmt->sNodeDBTable[uNodeIndex].eNodeState >= NODE_AUTH) {
716 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_ASSOC;
717 pMgmt->sNodeDBTable[uNodeIndex].wCapInfo = cpu_to_le16(*sFrame.pwCapInfo);
718 pMgmt->sNodeDBTable[uNodeIndex].wListenInterval = cpu_to_le16(*sFrame.pwListenInterval);
719 pMgmt->sNodeDBTable[uNodeIndex].bPSEnable =
720 WLAN_GET_FC_PWRMGT(sFrame.pHdr->sA3.wFrameCtl) ? TRUE : FALSE;
721
722 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
723 uRateLen = WLAN_RATES_MAXLEN_11B;
724 }
725 abyCurrSuppRates[0] = WLAN_EID_SUPP_RATES;
726 abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
727 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
728 uRateLen);
729 abyCurrExtSuppRates[0] = WLAN_EID_EXTSUPP_RATES;
730 if (pDevice->eCurrentPHYType == PHY_TYPE_11G) {
731 abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pExtSuppRates,
732 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
733 uRateLen);
734 } else {
735 abyCurrExtSuppRates[1] = 0;
736 }
737
738
739 RATEvParseMaxRate((PVOID)pDevice,
740 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
741 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
742 FALSE,
743 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxBasicRate),
744 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate),
745 &(pMgmt->sNodeDBTable[uNodeIndex].wSuppRate),
746 &(pMgmt->sNodeDBTable[uNodeIndex].byTopCCKBasicRate),
747 &(pMgmt->sNodeDBTable[uNodeIndex].byTopOFDMBasicRate)
748 );
749
750
751 pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate =
752 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate;
753#ifdef PLICE_DEBUG
754 printk("RxAssocRequest:wTxDataRate is %d\n",pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate);
755#endif
756
757 pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble =
758 WLAN_GET_CAP_INFO_SHORTPREAMBLE(*sFrame.pwCapInfo);
759 pMgmt->sNodeDBTable[uNodeIndex].bShortSlotTime =
760 WLAN_GET_CAP_INFO_SHORTSLOTTIME(*sFrame.pwCapInfo);
761 pMgmt->sNodeDBTable[uNodeIndex].wAID = (WORD)uNodeIndex;
762 wAssocStatus = WLAN_MGMT_STATUS_SUCCESS;
763 wAssocAID = (WORD)uNodeIndex;
764
765 if(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate > RATE_11M)
766 pMgmt->sNodeDBTable[uNodeIndex].bERPExist = TRUE;
767
768 if (pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate <= RATE_11M) {
769
770 pDevice->bProtectMode = TRUE;
771 pDevice->bNonERPPresent = TRUE;
772 }
773 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble == FALSE) {
774 pDevice->bBarkerPreambleMd = TRUE;
775 }
776
777 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Associate AID= %d \n", wAssocAID);
778 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "MAC=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \n",
779 sFrame.pHdr->sA3.abyAddr2[0],
780 sFrame.pHdr->sA3.abyAddr2[1],
781 sFrame.pHdr->sA3.abyAddr2[2],
782 sFrame.pHdr->sA3.abyAddr2[3],
783 sFrame.pHdr->sA3.abyAddr2[4],
784 sFrame.pHdr->sA3.abyAddr2[5]
785 ) ;
786 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Max Support rate = %d \n",
787 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate);
788 }
789 else {
790 return;
791 }
792
793
794
795 pTxPacket = s_MgrMakeAssocResponse
796 (
797 pDevice,
798 pMgmt,
799 pMgmt->wCurrCapInfo,
800 wAssocStatus,
801 wAssocAID,
802 sFrame.pHdr->sA3.abyAddr2,
803 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
804 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
805 );
806 if (pTxPacket != NULL ){
807
808 if (pDevice->bEnableHostapd) {
809 return;
810 }
811
812 Status = csMgmt_xmit(pDevice, pTxPacket);
813 if (Status != CMD_STATUS_PENDING) {
814 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Assoc response tx failed\n");
815 }
816 else {
817 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Assoc response tx sending..\n");
818 }
819
820 }
821
822 return;
823}
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842static
843VOID
844s_vMgrRxReAssocRequest(
845 IN PSDevice pDevice,
846 IN PSMgmtObject pMgmt,
847 IN PSRxMgmtPacket pRxPacket,
848 IN UINT uNodeIndex
849 )
850{
851 WLAN_FR_REASSOCREQ sFrame;
852 CMD_STATUS Status;
853 PSTxMgmtPacket pTxPacket;
854 WORD wAssocStatus = 0;
855 WORD wAssocAID = 0;
856 UINT uRateLen = WLAN_RATES_MAXLEN;
857 BYTE abyCurrSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
858 BYTE abyCurrExtSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
859
860 if (pMgmt->eCurrMode != WMAC_MODE_ESS_AP)
861 return;
862
863 if (!uNodeIndex)
864 return;
865
866
867 memset(&sFrame, 0, sizeof(WLAN_FR_REASSOCREQ));
868 sFrame.len = pRxPacket->cbMPDULen;
869 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
870 vMgrDecodeReassocRequest(&sFrame);
871
872 if (pMgmt->sNodeDBTable[uNodeIndex].eNodeState >= NODE_AUTH) {
873 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_ASSOC;
874 pMgmt->sNodeDBTable[uNodeIndex].wCapInfo = cpu_to_le16(*sFrame.pwCapInfo);
875 pMgmt->sNodeDBTable[uNodeIndex].wListenInterval = cpu_to_le16(*sFrame.pwListenInterval);
876 pMgmt->sNodeDBTable[uNodeIndex].bPSEnable =
877 WLAN_GET_FC_PWRMGT(sFrame.pHdr->sA3.wFrameCtl) ? TRUE : FALSE;
878
879
880 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
881 uRateLen = WLAN_RATES_MAXLEN_11B;
882 }
883
884 abyCurrSuppRates[0] = WLAN_EID_SUPP_RATES;
885 abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
886 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
887 uRateLen);
888 abyCurrExtSuppRates[0] = WLAN_EID_EXTSUPP_RATES;
889 if (pDevice->eCurrentPHYType == PHY_TYPE_11G) {
890 abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pExtSuppRates,
891 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
892 uRateLen);
893 } else {
894 abyCurrExtSuppRates[1] = 0;
895 }
896
897
898 RATEvParseMaxRate((PVOID)pDevice,
899 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
900 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
901 FALSE,
902 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxBasicRate),
903 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate),
904 &(pMgmt->sNodeDBTable[uNodeIndex].wSuppRate),
905 &(pMgmt->sNodeDBTable[uNodeIndex].byTopCCKBasicRate),
906 &(pMgmt->sNodeDBTable[uNodeIndex].byTopOFDMBasicRate)
907 );
908
909
910 pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate =
911 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate;
912#ifdef PLICE_DEBUG
913 printk("RxReAssocRequest:TxDataRate is %d\n",pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate);
914#endif
915
916 pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble =
917 WLAN_GET_CAP_INFO_SHORTPREAMBLE(*sFrame.pwCapInfo);
918 pMgmt->sNodeDBTable[uNodeIndex].bShortSlotTime =
919 WLAN_GET_CAP_INFO_SHORTSLOTTIME(*sFrame.pwCapInfo);
920 pMgmt->sNodeDBTable[uNodeIndex].wAID = (WORD)uNodeIndex;
921 wAssocStatus = WLAN_MGMT_STATUS_SUCCESS;
922 wAssocAID = (WORD)uNodeIndex;
923
924
925 if(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate > RATE_11M)
926 pMgmt->sNodeDBTable[uNodeIndex].bERPExist = TRUE;
927
928 if (pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate <= RATE_11M) {
929
930 pDevice->bProtectMode = TRUE;
931 pDevice->bNonERPPresent = TRUE;
932 }
933 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble == FALSE) {
934 pDevice->bBarkerPreambleMd = TRUE;
935 }
936
937 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Rx ReAssociate AID= %d \n", wAssocAID);
938 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "MAC=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \n",
939 sFrame.pHdr->sA3.abyAddr2[0],
940 sFrame.pHdr->sA3.abyAddr2[1],
941 sFrame.pHdr->sA3.abyAddr2[2],
942 sFrame.pHdr->sA3.abyAddr2[3],
943 sFrame.pHdr->sA3.abyAddr2[4],
944 sFrame.pHdr->sA3.abyAddr2[5]
945 ) ;
946 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Max Support rate = %d \n",
947 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate);
948
949 }
950
951
952
953 pTxPacket = s_MgrMakeReAssocResponse
954 (
955 pDevice,
956 pMgmt,
957 pMgmt->wCurrCapInfo,
958 wAssocStatus,
959 wAssocAID,
960 sFrame.pHdr->sA3.abyAddr2,
961 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
962 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
963 );
964
965 if (pTxPacket != NULL ){
966
967 if (pDevice->bEnableHostapd) {
968 return;
969 }
970 Status = csMgmt_xmit(pDevice, pTxPacket);
971 if (Status != CMD_STATUS_PENDING) {
972 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:ReAssoc response tx failed\n");
973 }
974 else {
975 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:ReAssoc response tx sending..\n");
976 }
977 }
978 return;
979}
980
981
982
983
984
985
986
987
988
989
990
991
992static
993VOID
994s_vMgrRxAssocResponse(
995 IN PSDevice pDevice,
996 IN PSMgmtObject pMgmt,
997 IN PSRxMgmtPacket pRxPacket,
998 IN BOOL bReAssocType
999 )
1000{
1001 WLAN_FR_ASSOCRESP sFrame;
1002 PWLAN_IE_SSID pItemSSID;
1003 PBYTE pbyIEs;
1004 viawget_wpa_header *wpahdr;
1005
1006
1007
1008 if (pMgmt->eCurrState == WMAC_STATE_ASSOCPENDING ||
1009 pMgmt->eCurrState == WMAC_STATE_ASSOC) {
1010
1011 sFrame.len = pRxPacket->cbMPDULen;
1012 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1013
1014 vMgrDecodeAssocResponse(&sFrame);
1015 if ((sFrame.pwCapInfo == 0) ||
1016 (sFrame.pwStatus == 0) ||
1017 (sFrame.pwAid == 0) ||
1018 (sFrame.pSuppRates == 0)){
1019 DBG_PORT80(0xCC);
1020 return;
1021 };
1022
1023 pMgmt->sAssocInfo.AssocInfo.ResponseFixedIEs.Capabilities = *(sFrame.pwCapInfo);
1024 pMgmt->sAssocInfo.AssocInfo.ResponseFixedIEs.StatusCode = *(sFrame.pwStatus);
1025 pMgmt->sAssocInfo.AssocInfo.ResponseFixedIEs.AssociationId = *(sFrame.pwAid);
1026 pMgmt->sAssocInfo.AssocInfo.AvailableResponseFixedIEs |= 0x07;
1027
1028 pMgmt->sAssocInfo.AssocInfo.ResponseIELength = sFrame.len - 24 - 6;
1029 pMgmt->sAssocInfo.AssocInfo.OffsetResponseIEs = pMgmt->sAssocInfo.AssocInfo.OffsetRequestIEs + pMgmt->sAssocInfo.AssocInfo.RequestIELength;
1030 pbyIEs = pMgmt->sAssocInfo.abyIEs;
1031 pbyIEs += pMgmt->sAssocInfo.AssocInfo.RequestIELength;
1032 memcpy(pbyIEs, (sFrame.pBuf + 24 +6), pMgmt->sAssocInfo.AssocInfo.ResponseIELength);
1033
1034
1035 if (cpu_to_le16((*(sFrame.pwStatus))) == WLAN_MGMT_STATUS_SUCCESS ){
1036
1037 pMgmt->wCurrAID = cpu_to_le16((*(sFrame.pwAid)));
1038 if ( (pMgmt->wCurrAID >> 14) != (BIT0 | BIT1) )
1039 {
1040 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "AID from AP, has two msb clear.\n");
1041 };
1042 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Association Successful, AID=%d.\n", pMgmt->wCurrAID & ~(BIT14|BIT15));
1043 pMgmt->eCurrState = WMAC_STATE_ASSOC;
1044 BSSvUpdateAPNode((HANDLE)pDevice, sFrame.pwCapInfo, sFrame.pSuppRates, sFrame.pExtSuppRates);
1045 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
1046 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Link with AP(SSID): %s\n", pItemSSID->abySSID);
1047 pDevice->bLinkPass = TRUE;
1048 pDevice->uBBVGADiffCount = 0;
1049 if ((pDevice->bWPADEVUp) && (pDevice->skb != NULL)) {
1050 if(skb_tailroom(pDevice->skb) <(sizeof(viawget_wpa_header)+pMgmt->sAssocInfo.AssocInfo.ResponseIELength+
1051 pMgmt->sAssocInfo.AssocInfo.RequestIELength)) {
1052 dev_kfree_skb(pDevice->skb);
1053 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1054 }
1055 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
1056 wpahdr->type = VIAWGET_ASSOC_MSG;
1057 wpahdr->resp_ie_len = pMgmt->sAssocInfo.AssocInfo.ResponseIELength;
1058 wpahdr->req_ie_len = pMgmt->sAssocInfo.AssocInfo.RequestIELength;
1059 memcpy(pDevice->skb->data + sizeof(viawget_wpa_header), pMgmt->sAssocInfo.abyIEs, wpahdr->req_ie_len);
1060 memcpy(pDevice->skb->data + sizeof(viawget_wpa_header) + wpahdr->req_ie_len,
1061 pbyIEs,
1062 wpahdr->resp_ie_len
1063 );
1064 skb_put(pDevice->skb, sizeof(viawget_wpa_header) + wpahdr->resp_ie_len + wpahdr->req_ie_len);
1065 pDevice->skb->dev = pDevice->wpadev;
1066 skb_reset_mac_header(pDevice->skb);
1067 pDevice->skb->pkt_type = PACKET_HOST;
1068 pDevice->skb->protocol = htons(ETH_P_802_2);
1069 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
1070 netif_rx(pDevice->skb);
1071 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1072 }
1073
1074
1075#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1076
1077 {
1078 BYTE buf[512];
1079 size_t len;
1080 union iwreq_data wrqu;
1081 int we_event;
1082
1083 memset(buf, 0, 512);
1084
1085 len = pMgmt->sAssocInfo.AssocInfo.RequestIELength;
1086 if(len) {
1087 memcpy(buf, pMgmt->sAssocInfo.abyIEs, len);
1088 memset(&wrqu, 0, sizeof (wrqu));
1089 wrqu.data.length = len;
1090 we_event = IWEVASSOCREQIE;
1091 wireless_send_event(pDevice->dev, we_event, &wrqu, buf);
1092 }
1093
1094 memset(buf, 0, 512);
1095 len = pMgmt->sAssocInfo.AssocInfo.ResponseIELength;
1096
1097 if(len) {
1098 memcpy(buf, pbyIEs, len);
1099 memset(&wrqu, 0, sizeof (wrqu));
1100 wrqu.data.length = len;
1101 we_event = IWEVASSOCRESPIE;
1102 wireless_send_event(pDevice->dev, we_event, &wrqu, buf);
1103 }
1104
1105
1106 memset(&wrqu, 0, sizeof (wrqu));
1107 memcpy(wrqu.ap_addr.sa_data, &pMgmt->abyCurrBSSID[0], ETH_ALEN);
1108 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1109 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1110 }
1111#endif
1112
1113 }
1114 else {
1115 if (bReAssocType) {
1116 pMgmt->eCurrState = WMAC_STATE_IDLE;
1117 }
1118 else {
1119
1120 pMgmt->eCurrState = WMAC_STATE_AUTH;
1121 }
1122 s_vMgrLogStatus(pMgmt,cpu_to_le16((*(sFrame.pwStatus))));
1123 }
1124
1125 }
1126
1127#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1128
1129
1130 pDevice->bwextcount = 0;
1131 pDevice->bWPASuppWextEnabled = FALSE;
1132#endif
1133
1134
1135if(pMgmt->eCurrState == WMAC_STATE_ASSOC)
1136 timer_expire(pDevice->sTimerCommand, 0);
1137 return;
1138}
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153VOID
1154vMgrAuthenBeginSta(
1155 IN HANDLE hDeviceContext,
1156 IN PSMgmtObject pMgmt,
1157 OUT PCMD_STATUS pStatus
1158 )
1159{
1160 PSDevice pDevice = (PSDevice)hDeviceContext;
1161 WLAN_FR_AUTHEN sFrame;
1162 PSTxMgmtPacket pTxPacket = NULL;
1163
1164 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1165 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1166 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1167 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1168 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1169 vMgrEncodeAuthen(&sFrame);
1170
1171 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1172 (
1173 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1174 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)
1175 ));
1176 memcpy( sFrame.pHdr->sA3.abyAddr1, pMgmt->abyCurrBSSID, WLAN_ADDR_LEN);
1177 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1178 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1179 if (pMgmt->bShareKeyAlgorithm)
1180 *(sFrame.pwAuthAlgorithm) = cpu_to_le16(WLAN_AUTH_ALG_SHAREDKEY);
1181 else
1182 *(sFrame.pwAuthAlgorithm) = cpu_to_le16(WLAN_AUTH_ALG_OPENSYSTEM);
1183
1184 *(sFrame.pwAuthSequence) = cpu_to_le16(1);
1185
1186 pTxPacket->cbMPDULen = sFrame.len;
1187 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1188
1189 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
1190 if (*pStatus == CMD_STATUS_PENDING){
1191 pMgmt->eCurrState = WMAC_STATE_AUTHPENDING;
1192 *pStatus = CMD_STATUS_SUCCESS;
1193 }
1194
1195 return ;
1196}
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211VOID
1212vMgrDeAuthenBeginSta(
1213 IN HANDLE hDeviceContext,
1214 IN PSMgmtObject pMgmt,
1215 IN PBYTE abyDestAddress,
1216 IN WORD wReason,
1217 OUT PCMD_STATUS pStatus
1218 )
1219{
1220 PSDevice pDevice = (PSDevice)hDeviceContext;
1221 WLAN_FR_DEAUTHEN sFrame;
1222 PSTxMgmtPacket pTxPacket = NULL;
1223
1224
1225 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1226 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_DEAUTHEN_FR_MAXLEN);
1227 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1228 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1229 sFrame.len = WLAN_DEAUTHEN_FR_MAXLEN;
1230 vMgrEncodeDeauthen(&sFrame);
1231
1232 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1233 (
1234 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1235 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_DEAUTHEN)
1236 ));
1237
1238 memcpy( sFrame.pHdr->sA3.abyAddr1, abyDestAddress, WLAN_ADDR_LEN);
1239 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1240 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1241
1242 *(sFrame.pwReason) = cpu_to_le16(wReason);
1243
1244 pTxPacket->cbMPDULen = sFrame.len;
1245 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1246
1247 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
1248 if (*pStatus == CMD_STATUS_PENDING){
1249 *pStatus = CMD_STATUS_SUCCESS;
1250 }
1251
1252
1253 return ;
1254}
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267static
1268VOID
1269s_vMgrRxAuthentication(
1270 IN PSDevice pDevice,
1271 IN PSMgmtObject pMgmt,
1272 IN PSRxMgmtPacket pRxPacket
1273 )
1274{
1275 WLAN_FR_AUTHEN sFrame;
1276
1277
1278 if (!(pMgmt->eCurrMode == WMAC_MODE_ESS_AP ||
1279 pMgmt->eCurrState == WMAC_STATE_AUTHPENDING)) {
1280 return;
1281 }
1282
1283
1284 sFrame.len = pRxPacket->cbMPDULen;
1285 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1286 vMgrDecodeAuthen(&sFrame);
1287 switch (cpu_to_le16((*(sFrame.pwAuthSequence )))){
1288 case 1:
1289
1290 s_vMgrRxAuthenSequence_1(pDevice,pMgmt, &sFrame);
1291 break;
1292 case 2:
1293 s_vMgrRxAuthenSequence_2(pDevice, pMgmt, &sFrame);
1294 break;
1295 case 3:
1296
1297 s_vMgrRxAuthenSequence_3(pDevice, pMgmt, &sFrame);
1298 break;
1299 case 4:
1300 s_vMgrRxAuthenSequence_4(pDevice, pMgmt, &sFrame);
1301 break;
1302 default:
1303 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Auth Sequence error, seq = %d\n",
1304 cpu_to_le16((*(sFrame.pwAuthSequence))));
1305 break;
1306 }
1307 return;
1308}
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325static
1326VOID
1327s_vMgrRxAuthenSequence_1(
1328 IN PSDevice pDevice,
1329 IN PSMgmtObject pMgmt,
1330 IN PWLAN_FR_AUTHEN pFrame
1331 )
1332{
1333 PSTxMgmtPacket pTxPacket = NULL;
1334 UINT uNodeIndex;
1335 WLAN_FR_AUTHEN sFrame;
1336 PSKeyItem pTransmitKey;
1337
1338
1339 if (!BSSDBbIsSTAInNodeDB(pMgmt, pFrame->pHdr->sA3.abyAddr2, &uNodeIndex)) {
1340 BSSvCreateOneNode((PSDevice)pDevice, &uNodeIndex);
1341 memcpy(pMgmt->sNodeDBTable[uNodeIndex].abyMACAddr, pFrame->pHdr->sA3.abyAddr2,
1342 WLAN_ADDR_LEN);
1343 }
1344
1345 if (pMgmt->bShareKeyAlgorithm) {
1346 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_KNOWN;
1347 pMgmt->sNodeDBTable[uNodeIndex].byAuthSequence = 1;
1348 }
1349 else {
1350 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_AUTH;
1351 }
1352
1353
1354 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1355 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1356 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1357 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1358 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1359
1360 vMgrEncodeAuthen(&sFrame);
1361
1362 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1363 (
1364 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1365 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)|
1366 WLAN_SET_FC_ISWEP(0)
1367 ));
1368 memcpy( sFrame.pHdr->sA3.abyAddr1, pFrame->pHdr->sA3.abyAddr2, WLAN_ADDR_LEN);
1369 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1370 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1371 *(sFrame.pwAuthAlgorithm) = *(pFrame->pwAuthAlgorithm);
1372 *(sFrame.pwAuthSequence) = cpu_to_le16(2);
1373
1374 if (cpu_to_le16(*(pFrame->pwAuthAlgorithm)) == WLAN_AUTH_ALG_SHAREDKEY) {
1375 if (pMgmt->bShareKeyAlgorithm)
1376 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_SUCCESS);
1377 else
1378 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_UNSUPPORTED_AUTHALG);
1379 }
1380 else {
1381 if (pMgmt->bShareKeyAlgorithm)
1382 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_UNSUPPORTED_AUTHALG);
1383 else
1384 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_SUCCESS);
1385 }
1386
1387 if (pMgmt->bShareKeyAlgorithm &&
1388 (cpu_to_le16(*(sFrame.pwStatus)) == WLAN_MGMT_STATUS_SUCCESS)) {
1389
1390 sFrame.pChallenge = (PWLAN_IE_CHALLENGE)(sFrame.pBuf + sFrame.len);
1391 sFrame.len += WLAN_CHALLENGE_IE_LEN;
1392 sFrame.pChallenge->byElementID = WLAN_EID_CHALLENGE;
1393 sFrame.pChallenge->len = WLAN_CHALLENGE_LEN;
1394 memset(pMgmt->abyChallenge, 0, WLAN_CHALLENGE_LEN);
1395
1396 if(KeybGetTransmitKey(&(pDevice->sKey), pDevice->abyBroadcastAddr, GROUP_KEY, &pTransmitKey) == TRUE) {
1397 rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength+3);
1398 rc4_encrypt(&pDevice->SBox, pMgmt->abyChallenge, pMgmt->abyChallenge, WLAN_CHALLENGE_LEN);
1399 }
1400 memcpy(sFrame.pChallenge->abyChallenge, pMgmt->abyChallenge , WLAN_CHALLENGE_LEN);
1401 }
1402
1403
1404 pTxPacket->cbMPDULen = sFrame.len;
1405 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1406
1407 if (pDevice->bEnableHostapd) {
1408 return;
1409 }
1410 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Authreq_reply sequence_1 tx.. \n");
1411 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) {
1412 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Authreq_reply sequence_1 tx failed.\n");
1413 }
1414 return;
1415}
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431static
1432VOID
1433s_vMgrRxAuthenSequence_2(
1434 IN PSDevice pDevice,
1435 IN PSMgmtObject pMgmt,
1436 IN PWLAN_FR_AUTHEN pFrame
1437 )
1438{
1439 WLAN_FR_AUTHEN sFrame;
1440 PSTxMgmtPacket pTxPacket = NULL;
1441
1442
1443 switch (cpu_to_le16((*(pFrame->pwAuthAlgorithm))))
1444 {
1445 case WLAN_AUTH_ALG_OPENSYSTEM:
1446 if ( cpu_to_le16((*(pFrame->pwStatus))) == WLAN_MGMT_STATUS_SUCCESS ){
1447 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (OPEN) Successful.\n");
1448 pMgmt->eCurrState = WMAC_STATE_AUTH;
1449 timer_expire(pDevice->sTimerCommand, 0);
1450 }
1451 else {
1452 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (OPEN) Failed.\n");
1453 s_vMgrLogStatus(pMgmt, cpu_to_le16((*(pFrame->pwStatus))));
1454 pMgmt->eCurrState = WMAC_STATE_IDLE;
1455 }
1456 if (pDevice->eCommandState == WLAN_AUTHENTICATE_WAIT ) {
1457
1458
1459
1460 }
1461
1462 break;
1463
1464 case WLAN_AUTH_ALG_SHAREDKEY:
1465
1466 if (cpu_to_le16((*(pFrame->pwStatus))) == WLAN_MGMT_STATUS_SUCCESS) {
1467 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1468 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1469 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1470 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1471 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1472
1473 vMgrEncodeAuthen(&sFrame);
1474
1475 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1476 (
1477 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1478 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)|
1479 WLAN_SET_FC_ISWEP(1)
1480 ));
1481 memcpy( sFrame.pHdr->sA3.abyAddr1, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1482 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1483 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1484 *(sFrame.pwAuthAlgorithm) = *(pFrame->pwAuthAlgorithm);
1485 *(sFrame.pwAuthSequence) = cpu_to_le16(3);
1486 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_SUCCESS);
1487 sFrame.pChallenge = (PWLAN_IE_CHALLENGE)(sFrame.pBuf + sFrame.len);
1488 sFrame.len += WLAN_CHALLENGE_IE_LEN;
1489 sFrame.pChallenge->byElementID = WLAN_EID_CHALLENGE;
1490 sFrame.pChallenge->len = WLAN_CHALLENGE_LEN;
1491 memcpy( sFrame.pChallenge->abyChallenge, pFrame->pChallenge->abyChallenge, WLAN_CHALLENGE_LEN);
1492
1493 pTxPacket->cbMPDULen = sFrame.len;
1494 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1495
1496 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) {
1497 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Auth_reply sequence_2 tx failed.\n");
1498 }
1499 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Auth_reply sequence_2 tx ...\n");
1500 }
1501 else {
1502 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:rx Auth_reply sequence_2 status error ...\n");
1503 if ( pDevice->eCommandState == WLAN_AUTHENTICATE_WAIT ) {
1504
1505
1506
1507 }
1508 s_vMgrLogStatus(pMgmt, cpu_to_le16((*(pFrame->pwStatus))));
1509 }
1510 break;
1511 default:
1512 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt: rx auth.seq = 2 unknown AuthAlgorithm=%d\n", cpu_to_le16((*(pFrame->pwAuthAlgorithm))));
1513 break;
1514 }
1515 return;
1516}
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533static
1534VOID
1535s_vMgrRxAuthenSequence_3(
1536 IN PSDevice pDevice,
1537 IN PSMgmtObject pMgmt,
1538 IN PWLAN_FR_AUTHEN pFrame
1539 )
1540{
1541 PSTxMgmtPacket pTxPacket = NULL;
1542 UINT uStatusCode = 0 ;
1543 UINT uNodeIndex = 0;
1544 WLAN_FR_AUTHEN sFrame;
1545
1546 if (!WLAN_GET_FC_ISWEP(pFrame->pHdr->sA3.wFrameCtl)) {
1547 uStatusCode = WLAN_MGMT_STATUS_CHALLENGE_FAIL;
1548 goto reply;
1549 }
1550 if (BSSDBbIsSTAInNodeDB(pMgmt, pFrame->pHdr->sA3.abyAddr2, &uNodeIndex)) {
1551 if (pMgmt->sNodeDBTable[uNodeIndex].byAuthSequence != 1) {
1552 uStatusCode = WLAN_MGMT_STATUS_RX_AUTH_NOSEQ;
1553 goto reply;
1554 }
1555 if (memcmp(pMgmt->abyChallenge, pFrame->pChallenge->abyChallenge, WLAN_CHALLENGE_LEN) != 0) {
1556 uStatusCode = WLAN_MGMT_STATUS_CHALLENGE_FAIL;
1557 goto reply;
1558 }
1559 }
1560 else {
1561 uStatusCode = WLAN_MGMT_STATUS_UNSPEC_FAILURE;
1562 goto reply;
1563 }
1564
1565 if (uNodeIndex) {
1566 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_AUTH;
1567 pMgmt->sNodeDBTable[uNodeIndex].byAuthSequence = 0;
1568 }
1569 uStatusCode = WLAN_MGMT_STATUS_SUCCESS;
1570 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Challenge text check ok..\n");
1571
1572reply:
1573
1574 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1575 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1576 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1577 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1578 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1579
1580 vMgrEncodeAuthen(&sFrame);
1581
1582 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1583 (
1584 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1585 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)|
1586 WLAN_SET_FC_ISWEP(0)
1587 ));
1588 memcpy( sFrame.pHdr->sA3.abyAddr1, pFrame->pHdr->sA3.abyAddr2, WLAN_ADDR_LEN);
1589 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1590 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1591 *(sFrame.pwAuthAlgorithm) = *(pFrame->pwAuthAlgorithm);
1592 *(sFrame.pwAuthSequence) = cpu_to_le16(4);
1593 *(sFrame.pwStatus) = cpu_to_le16(uStatusCode);
1594
1595
1596 pTxPacket->cbMPDULen = sFrame.len;
1597 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1598
1599 if (pDevice->bEnableHostapd) {
1600 return;
1601 }
1602 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) {
1603 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Authreq_reply sequence_4 tx failed.\n");
1604 }
1605 return;
1606
1607}
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621static
1622VOID
1623s_vMgrRxAuthenSequence_4(
1624 IN PSDevice pDevice,
1625 IN PSMgmtObject pMgmt,
1626 IN PWLAN_FR_AUTHEN pFrame
1627 )
1628{
1629
1630 if ( cpu_to_le16((*(pFrame->pwStatus))) == WLAN_MGMT_STATUS_SUCCESS ){
1631 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (SHAREDKEY) Successful.\n");
1632 pMgmt->eCurrState = WMAC_STATE_AUTH;
1633 timer_expire(pDevice->sTimerCommand, 0);
1634 }
1635 else{
1636 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (SHAREDKEY) Failed.\n");
1637 s_vMgrLogStatus(pMgmt, cpu_to_le16((*(pFrame->pwStatus))) );
1638 pMgmt->eCurrState = WMAC_STATE_IDLE;
1639 }
1640
1641 if ( pDevice->eCommandState == WLAN_AUTHENTICATE_WAIT ) {
1642
1643
1644
1645 }
1646
1647}
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660static
1661VOID
1662s_vMgrRxDisassociation(
1663 IN PSDevice pDevice,
1664 IN PSMgmtObject pMgmt,
1665 IN PSRxMgmtPacket pRxPacket
1666 )
1667{
1668 WLAN_FR_DISASSOC sFrame;
1669 UINT uNodeIndex = 0;
1670
1671 viawget_wpa_header *wpahdr;
1672
1673 if ( pMgmt->eCurrMode == WMAC_MODE_ESS_AP ){
1674
1675
1676 sFrame.len = pRxPacket->cbMPDULen;
1677 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1678 if (BSSDBbIsSTAInNodeDB(pMgmt, pRxPacket->p80211Header->sA3.abyAddr2, &uNodeIndex)) {
1679 BSSvRemoveOneNode(pDevice, uNodeIndex);
1680 }
1681 else {
1682 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Rx disassoc, sta not found\n");
1683 }
1684 }
1685 else if (pMgmt->eCurrMode == WMAC_MODE_ESS_STA ){
1686 sFrame.len = pRxPacket->cbMPDULen;
1687 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1688 vMgrDecodeDisassociation(&sFrame);
1689 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "AP disassociated me, reason=%d.\n", cpu_to_le16(*(sFrame.pwReason)));
1690
1691
1692
1693
1694
1695 if ((pDevice->bWPADEVUp) && (pDevice->skb != NULL)) {
1696 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
1697 wpahdr->type = VIAWGET_DISASSOC_MSG;
1698 wpahdr->resp_ie_len = 0;
1699 wpahdr->req_ie_len = 0;
1700 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
1701 pDevice->skb->dev = pDevice->wpadev;
1702 skb_reset_mac_header(pDevice->skb);
1703
1704 pDevice->skb->pkt_type = PACKET_HOST;
1705 pDevice->skb->protocol = htons(ETH_P_802_2);
1706 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
1707 netif_rx(pDevice->skb);
1708 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1709 };
1710
1711 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1712
1713 {
1714 union iwreq_data wrqu;
1715 memset(&wrqu, 0, sizeof (wrqu));
1716 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1717 printk("wireless_send_event--->SIOCGIWAP(disassociated)\n");
1718 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1719 }
1720 #endif
1721 }
1722
1723
1724 return;
1725}
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739static
1740VOID
1741s_vMgrRxDeauthentication(
1742 IN PSDevice pDevice,
1743 IN PSMgmtObject pMgmt,
1744 IN PSRxMgmtPacket pRxPacket
1745 )
1746{
1747 WLAN_FR_DEAUTHEN sFrame;
1748 UINT uNodeIndex = 0;
1749 viawget_wpa_header *wpahdr;
1750
1751
1752 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP ){
1753
1754
1755
1756 sFrame.len = pRxPacket->cbMPDULen;
1757 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1758 if (BSSDBbIsSTAInNodeDB(pMgmt, pRxPacket->p80211Header->sA3.abyAddr2, &uNodeIndex)) {
1759 BSSvRemoveOneNode(pDevice, uNodeIndex);
1760 }
1761 else {
1762 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Rx deauth, sta not found\n");
1763 }
1764 }
1765 else {
1766 if (pMgmt->eCurrMode == WMAC_MODE_ESS_STA ) {
1767 sFrame.len = pRxPacket->cbMPDULen;
1768 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1769 vMgrDecodeDeauthen(&sFrame);
1770 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "AP deauthed me, reason=%d.\n", cpu_to_le16((*(sFrame.pwReason))));
1771
1772 if (IS_ETH_ADDRESS_EQUAL(sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID)) {
1773 if (pMgmt->eCurrState >= WMAC_STATE_AUTHPENDING) {
1774 pMgmt->sNodeDBTable[0].bActive = FALSE;
1775 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
1776 pMgmt->eCurrState = WMAC_STATE_IDLE;
1777 netif_stop_queue(pDevice->dev);
1778 pDevice->bLinkPass = FALSE;
1779 }
1780 };
1781
1782 if ((pDevice->bWPADEVUp) && (pDevice->skb != NULL)) {
1783 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
1784 wpahdr->type = VIAWGET_DISASSOC_MSG;
1785 wpahdr->resp_ie_len = 0;
1786 wpahdr->req_ie_len = 0;
1787 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
1788 pDevice->skb->dev = pDevice->wpadev;
1789 skb_reset_mac_header(pDevice->skb);
1790 pDevice->skb->pkt_type = PACKET_HOST;
1791 pDevice->skb->protocol = htons(ETH_P_802_2);
1792 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
1793 netif_rx(pDevice->skb);
1794 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1795 };
1796
1797 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1798
1799 {
1800 union iwreq_data wrqu;
1801 memset(&wrqu, 0, sizeof (wrqu));
1802 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1803 PRINT_K("wireless_send_event--->SIOCGIWAP(disauthen)\n");
1804 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1805 }
1806 #endif
1807
1808 }
1809
1810
1811 };
1812 return;
1813}
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828static BOOL
1829ChannelExceedZoneType(
1830 IN PSDevice pDevice,
1831 IN BYTE byCurrChannel
1832 )
1833{
1834 BOOL exceed=FALSE;
1835
1836 switch(pDevice->byZoneType) {
1837 case 0x00:
1838 if((byCurrChannel<1) ||(byCurrChannel>11))
1839 exceed = TRUE;
1840 break;
1841 case 0x01:
1842 case 0x02:
1843 if((byCurrChannel<1) ||(byCurrChannel>13))
1844 exceed = TRUE;
1845 break;
1846 default:
1847 break;
1848 }
1849
1850 return exceed;
1851}
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865static
1866VOID
1867s_vMgrRxBeacon(
1868 IN PSDevice pDevice,
1869 IN PSMgmtObject pMgmt,
1870 IN PSRxMgmtPacket pRxPacket,
1871 IN BOOL bInScan
1872 )
1873{
1874
1875 PKnownBSS pBSSList;
1876 WLAN_FR_BEACON sFrame;
1877 QWORD qwTSFOffset;
1878 BOOL bIsBSSIDEqual = FALSE;
1879 BOOL bIsSSIDEqual = FALSE;
1880 BOOL bTSFLargeDiff = FALSE;
1881 BOOL bTSFOffsetPostive = FALSE;
1882 BOOL bUpdateTSF = FALSE;
1883 BOOL bIsAPBeacon = FALSE;
1884 BOOL bIsChannelEqual = FALSE;
1885 UINT uLocateByteIndex;
1886 BYTE byTIMBitOn = 0;
1887 WORD wAIDNumber = 0;
1888 UINT uNodeIndex;
1889 QWORD qwTimestamp, qwLocalTSF;
1890 QWORD qwCurrTSF;
1891 WORD wStartIndex = 0;
1892 WORD wAIDIndex = 0;
1893 BYTE byCurrChannel = pRxPacket->byRxChannel;
1894 ERPObject sERP;
1895 UINT uRateLen = WLAN_RATES_MAXLEN;
1896 BOOL bChannelHit = FALSE;
1897 BOOL bUpdatePhyParameter = FALSE;
1898 BYTE byIEChannel = 0;
1899
1900
1901 memset(&sFrame, 0, sizeof(WLAN_FR_BEACON));
1902 sFrame.len = pRxPacket->cbMPDULen;
1903 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1904
1905
1906 vMgrDecodeBeacon(&sFrame);
1907
1908 if ((sFrame.pwBeaconInterval == 0) ||
1909 (sFrame.pwCapInfo == 0) ||
1910 (sFrame.pSSID == 0) ||
1911 (sFrame.pSuppRates == 0) ) {
1912 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Rx beacon frame error\n");
1913 return;
1914 };
1915
1916
1917 if (sFrame.pDSParms != NULL) {
1918 if (byCurrChannel > CB_MAX_CHANNEL_24G) {
1919
1920 byIEChannel = CARDbyGetChannelMapping(pDevice, sFrame.pDSParms->byCurrChannel, PHY_TYPE_11A);
1921 } else {
1922 byIEChannel = sFrame.pDSParms->byCurrChannel;
1923 }
1924 if (byCurrChannel != byIEChannel) {
1925
1926 bChannelHit = FALSE;
1927 byCurrChannel = byIEChannel;
1928 }
1929 } else {
1930
1931 bChannelHit = TRUE;
1932 }
1933
1934if(ChannelExceedZoneType(pDevice,byCurrChannel)==TRUE)
1935 return;
1936
1937 if (sFrame.pERP != NULL) {
1938 sERP.byERP = sFrame.pERP->byContext;
1939 sERP.bERPExist = TRUE;
1940
1941 } else {
1942 sERP.bERPExist = FALSE;
1943 sERP.byERP = 0;
1944 }
1945
1946 pBSSList = BSSpAddrIsInBSSList((HANDLE)pDevice, sFrame.pHdr->sA3.abyAddr3, sFrame.pSSID);
1947 if (pBSSList == NULL) {
1948 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Beacon/insert: RxChannel = : %d\n", byCurrChannel);
1949 BSSbInsertToBSSList((HANDLE)pDevice,
1950 sFrame.pHdr->sA3.abyAddr3,
1951 *sFrame.pqwTimestamp,
1952 *sFrame.pwBeaconInterval,
1953 *sFrame.pwCapInfo,
1954 byCurrChannel,
1955 sFrame.pSSID,
1956 sFrame.pSuppRates,
1957 sFrame.pExtSuppRates,
1958 &sERP,
1959 sFrame.pRSN,
1960 sFrame.pRSNWPA,
1961 sFrame.pIE_Country,
1962 sFrame.pIE_Quiet,
1963 sFrame.len - WLAN_HDR_ADDR3_LEN,
1964 sFrame.pHdr->sA4.abyAddr4,
1965 (HANDLE)pRxPacket
1966 );
1967 }
1968 else {
1969
1970 BSSbUpdateToBSSList((HANDLE)pDevice,
1971 *sFrame.pqwTimestamp,
1972 *sFrame.pwBeaconInterval,
1973 *sFrame.pwCapInfo,
1974 byCurrChannel,
1975 bChannelHit,
1976 sFrame.pSSID,
1977 sFrame.pSuppRates,
1978 sFrame.pExtSuppRates,
1979 &sERP,
1980 sFrame.pRSN,
1981 sFrame.pRSNWPA,
1982 sFrame.pIE_Country,
1983 sFrame.pIE_Quiet,
1984 pBSSList,
1985 sFrame.len - WLAN_HDR_ADDR3_LEN,
1986 sFrame.pHdr->sA4.abyAddr4,
1987 (HANDLE)pRxPacket
1988 );
1989
1990 }
1991
1992 if (bInScan) {
1993 return;
1994 }
1995
1996 if(byCurrChannel == (BYTE)pMgmt->uCurrChannel)
1997 bIsChannelEqual = TRUE;
1998
1999 if (bIsChannelEqual && (pMgmt->eCurrMode == WMAC_MODE_ESS_AP)) {
2000
2001
2002 if (sERP.bERPExist) {
2003 if (WLAN_GET_ERP_USE_PROTECTION(sERP.byERP)){
2004 pDevice->byERPFlag |= WLAN_SET_ERP_USE_PROTECTION(1);
2005 pDevice->wUseProtectCntDown = USE_PROTECT_PERIOD;
2006 }
2007 }
2008 else {
2009 pDevice->byERPFlag |= WLAN_SET_ERP_USE_PROTECTION(1);
2010 pDevice->wUseProtectCntDown = USE_PROTECT_PERIOD;
2011 }
2012
2013 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2014 if(!WLAN_GET_CAP_INFO_SHORTPREAMBLE(*sFrame.pwCapInfo))
2015 pDevice->byERPFlag |= WLAN_SET_ERP_BARKER_MODE(1);
2016 if(!sERP.bERPExist)
2017 pDevice->byERPFlag |= WLAN_SET_ERP_NONERP_PRESENT(1);
2018 }
2019
2020
2021 if (WLAN_GET_ERP_USE_PROTECTION(pDevice->byERPFlag)){
2022 if (!pDevice->bProtectMode) {
2023 MACvEnableProtectMD(pDevice->PortOffset);
2024 pDevice->bProtectMode = TRUE;
2025 }
2026 }
2027 }
2028
2029
2030 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP)
2031 return;
2032
2033
2034 if (memcmp(sFrame.pHdr->sA3.abyAddr3,
2035 pMgmt->abyCurrBSSID,
2036 WLAN_BSSID_LEN) == 0) {
2037
2038 bIsBSSIDEqual = TRUE;
2039
2040
2041 pDevice->uCurrRSSI = pRxPacket->uRSSI;
2042 pDevice->byCurrSQ = pRxPacket->bySQ;
2043
2044 if (pMgmt->sNodeDBTable[0].uInActiveCount != 0) {
2045 pMgmt->sNodeDBTable[0].uInActiveCount = 0;
2046
2047 }
2048 }
2049
2050 if (sFrame.pSSID->len == ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len) {
2051 if (memcmp(sFrame.pSSID->abySSID,
2052 ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->abySSID,
2053 sFrame.pSSID->len
2054 ) == 0) {
2055 bIsSSIDEqual = TRUE;
2056 };
2057 }
2058
2059 if ((WLAN_GET_CAP_INFO_ESS(*sFrame.pwCapInfo)== TRUE) &&
2060 (bIsBSSIDEqual == TRUE) &&
2061 (bIsSSIDEqual == TRUE) &&
2062 (pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2063 (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2064
2065
2066 bIsAPBeacon = TRUE;
2067
2068 if (pBSSList != NULL) {
2069
2070
2071 if (pMgmt->wCurrCapInfo != pBSSList->wCapInfo) {
2072 bUpdatePhyParameter = TRUE;
2073 pMgmt->wCurrCapInfo = pBSSList->wCapInfo;
2074 }
2075 if (sFrame.pERP != NULL) {
2076 if ((sFrame.pERP->byElementID == WLAN_EID_ERP) &&
2077 (pMgmt->byERPContext != sFrame.pERP->byContext)) {
2078 bUpdatePhyParameter = TRUE;
2079 pMgmt->byERPContext = sFrame.pERP->byContext;
2080 }
2081 }
2082
2083
2084
2085 if (pBSSList->eNetworkTypeInUse == PHY_TYPE_11B) {
2086 uRateLen = WLAN_RATES_MAXLEN_11B;
2087 }
2088 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)pBSSList->abySuppRates,
2089 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2090 uRateLen);
2091 pMgmt->abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)pBSSList->abyExtSuppRates,
2092 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
2093 uRateLen);
2094 RATEvParseMaxRate( (PVOID)pDevice,
2095 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2096 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
2097 TRUE,
2098 &(pMgmt->sNodeDBTable[0].wMaxBasicRate),
2099 &(pMgmt->sNodeDBTable[0].wMaxSuppRate),
2100 &(pMgmt->sNodeDBTable[0].wSuppRate),
2101 &(pMgmt->sNodeDBTable[0].byTopCCKBasicRate),
2102 &(pMgmt->sNodeDBTable[0].byTopOFDMBasicRate)
2103 );
2104#ifdef PLICE_DEBUG
2105
2106#endif
2107 if (bUpdatePhyParameter == TRUE) {
2108 CARDbSetPhyParameter( pMgmt->pAdapter,
2109 pMgmt->eCurrentPHYMode,
2110 pMgmt->wCurrCapInfo,
2111 pMgmt->byERPContext,
2112 pMgmt->abyCurrSuppRates,
2113 pMgmt->abyCurrExtSuppRates
2114 );
2115 }
2116 if (sFrame.pIE_PowerConstraint != NULL) {
2117 CARDvSetPowerConstraint(pMgmt->pAdapter,
2118 (BYTE) pBSSList->uChannel,
2119 sFrame.pIE_PowerConstraint->byPower
2120 );
2121 }
2122 if (sFrame.pIE_CHSW != NULL) {
2123 CARDbChannelSwitch( pMgmt->pAdapter,
2124 sFrame.pIE_CHSW->byMode,
2125 CARDbyGetChannelMapping(pMgmt->pAdapter, sFrame.pIE_CHSW->byMode, pMgmt->eCurrentPHYMode),
2126 sFrame.pIE_CHSW->byCount
2127 );
2128
2129 } else if (bIsChannelEqual == FALSE) {
2130 CARDbSetChannel(pMgmt->pAdapter, pBSSList->uChannel);
2131 }
2132 }
2133 }
2134
2135
2136
2137 if (WLAN_GET_CAP_INFO_ESS(*sFrame.pwCapInfo)) {
2138 if (sFrame.pCFParms->wCFPDurRemaining > 0) {
2139
2140 };
2141 };
2142
2143 HIDWORD(qwTimestamp) = cpu_to_le32(HIDWORD(*sFrame.pqwTimestamp));
2144 LODWORD(qwTimestamp) = cpu_to_le32(LODWORD(*sFrame.pqwTimestamp));
2145 HIDWORD(qwLocalTSF) = HIDWORD(pRxPacket->qwLocalTSF);
2146 LODWORD(qwLocalTSF) = LODWORD(pRxPacket->qwLocalTSF);
2147
2148
2149 if (HIDWORD(qwTimestamp) == HIDWORD(qwLocalTSF)) {
2150 if (LODWORD(qwTimestamp) >= LODWORD(qwLocalTSF)) {
2151 bTSFOffsetPostive = TRUE;
2152 }
2153 else {
2154 bTSFOffsetPostive = FALSE;
2155 }
2156 }
2157 else if (HIDWORD(qwTimestamp) > HIDWORD(qwLocalTSF)) {
2158 bTSFOffsetPostive = TRUE;
2159 }
2160 else if (HIDWORD(qwTimestamp) < HIDWORD(qwLocalTSF)) {
2161 bTSFOffsetPostive = FALSE;
2162 };
2163
2164 if (bTSFOffsetPostive) {
2165 qwTSFOffset = CARDqGetTSFOffset(pRxPacket->byRxRate, (qwTimestamp), (qwLocalTSF));
2166 }
2167 else {
2168 qwTSFOffset = CARDqGetTSFOffset(pRxPacket->byRxRate, (qwLocalTSF), (qwTimestamp));
2169 }
2170
2171 if (HIDWORD(qwTSFOffset) != 0 ||
2172 (LODWORD(qwTSFOffset) > TRIVIAL_SYNC_DIFFERENCE )) {
2173 bTSFLargeDiff = TRUE;
2174 }
2175
2176
2177
2178 if (bIsAPBeacon == TRUE) {
2179
2180
2181 if (bTSFLargeDiff)
2182 bUpdateTSF = TRUE;
2183
2184 if ((pDevice->bEnablePSMode == TRUE) &&(sFrame.pTIM != 0)) {
2185
2186
2187 pMgmt->bMulticastTIM = WLAN_MGMT_IS_MULTICAST_TIM(sFrame.pTIM->byBitMapCtl) ? TRUE : FALSE ;
2188 pMgmt->byDTIMCount = sFrame.pTIM->byDTIMCount;
2189 pMgmt->byDTIMPeriod = sFrame.pTIM->byDTIMPeriod;
2190 wAIDNumber = pMgmt->wCurrAID & ~(BIT14|BIT15);
2191
2192
2193
2194 wStartIndex = WLAN_MGMT_GET_TIM_OFFSET(sFrame.pTIM->byBitMapCtl) << 1;
2195
2196 wAIDIndex = (wAIDNumber >> 3);
2197 if ((wAIDNumber > 0) && (wAIDIndex >= wStartIndex)) {
2198 uLocateByteIndex = wAIDIndex - wStartIndex;
2199
2200 if (sFrame.pTIM->len >= (uLocateByteIndex + 4)) {
2201 byTIMBitOn = (0x01) << ((wAIDNumber) % 8);
2202 pMgmt->bInTIM = sFrame.pTIM->byVirtBitMap[uLocateByteIndex] & byTIMBitOn ? TRUE : FALSE;
2203 }
2204 else {
2205 pMgmt->bInTIM = FALSE;
2206 };
2207 }
2208 else {
2209 pMgmt->bInTIM = FALSE;
2210 };
2211
2212 if (pMgmt->bInTIM ||
2213 (pMgmt->bMulticastTIM && (pMgmt->byDTIMCount == 0))) {
2214 pMgmt->bInTIMWake = TRUE;
2215
2216
2217 if (pMgmt->bInTIM) {
2218 PSvSendPSPOLL((PSDevice)pDevice);
2219
2220 };
2221
2222 }
2223 else {
2224 pMgmt->bInTIMWake = FALSE;
2225 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "BCN: Not In TIM..\n");
2226 if (pDevice->bPWBitOn == FALSE) {
2227 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "BCN: Send Null Packet\n");
2228 if (PSbSendNullPacket(pDevice))
2229 pDevice->bPWBitOn = TRUE;
2230 }
2231 if(PSbConsiderPowerDown(pDevice, FALSE, FALSE)) {
2232 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "BCN: Power down now...\n");
2233 };
2234 }
2235
2236 }
2237
2238 }
2239
2240 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && !bIsAPBeacon && bIsChannelEqual) {
2241 if (bIsBSSIDEqual) {
2242
2243 if (pMgmt->sNodeDBTable[0].uInActiveCount != 0)
2244 pMgmt->sNodeDBTable[0].uInActiveCount = 0;
2245
2246
2247 if (bTSFLargeDiff && bTSFOffsetPostive &&
2248 (pMgmt->eCurrState == WMAC_STATE_JOINTED))
2249 bUpdateTSF = TRUE;
2250
2251
2252 if (BSSDBbIsSTAInNodeDB(pMgmt, sFrame.pHdr->sA3.abyAddr2, &uNodeIndex)) {
2253
2254
2255
2256 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
2257 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2258 WLAN_RATES_MAXLEN_11B);
2259 RATEvParseMaxRate( (PVOID)pDevice,
2260 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2261 NULL,
2262 TRUE,
2263 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxBasicRate),
2264 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate),
2265 &(pMgmt->sNodeDBTable[uNodeIndex].wSuppRate),
2266 &(pMgmt->sNodeDBTable[uNodeIndex].byTopCCKBasicRate),
2267 &(pMgmt->sNodeDBTable[uNodeIndex].byTopOFDMBasicRate)
2268 );
2269 pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble = WLAN_GET_CAP_INFO_SHORTPREAMBLE(*sFrame.pwCapInfo);
2270 pMgmt->sNodeDBTable[uNodeIndex].bShortSlotTime = WLAN_GET_CAP_INFO_SHORTSLOTTIME(*sFrame.pwCapInfo);
2271 pMgmt->sNodeDBTable[uNodeIndex].uInActiveCount = 0;
2272 }
2273 else {
2274
2275 BSSvCreateOneNode((PSDevice)pDevice, &uNodeIndex);
2276
2277 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
2278 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2279 WLAN_RATES_MAXLEN_11B);
2280 RATEvParseMaxRate( (PVOID)pDevice,
2281 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2282 NULL,
2283 TRUE,
2284 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxBasicRate),
2285 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate),
2286 &(pMgmt->sNodeDBTable[uNodeIndex].wSuppRate),
2287 &(pMgmt->sNodeDBTable[uNodeIndex].byTopCCKBasicRate),
2288 &(pMgmt->sNodeDBTable[uNodeIndex].byTopOFDMBasicRate)
2289 );
2290
2291 memcpy(pMgmt->sNodeDBTable[uNodeIndex].abyMACAddr, sFrame.pHdr->sA3.abyAddr2, WLAN_ADDR_LEN);
2292 pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble = WLAN_GET_CAP_INFO_SHORTPREAMBLE(*sFrame.pwCapInfo);
2293 pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate = pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate;
2294#ifdef PLICE_DEBUG
2295
2296 {
2297 printk("s_vMgrRxBeacon:TxDataRate is %d,Index is %d\n",pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate,uNodeIndex);
2298 }
2299#endif
2300
2301
2302
2303
2304
2305 }
2306
2307
2308 if (pMgmt->eCurrState == WMAC_STATE_STARTED) {
2309 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Current IBSS State: [Started]........to: [Jointed] \n");
2310 pMgmt->eCurrState = WMAC_STATE_JOINTED;
2311 pDevice->bLinkPass = TRUE;
2312 if (netif_queue_stopped(pDevice->dev)){
2313 netif_wake_queue(pDevice->dev);
2314 }
2315 pMgmt->sNodeDBTable[0].bActive = TRUE;
2316 pMgmt->sNodeDBTable[0].uInActiveCount = 0;
2317
2318 };
2319 }
2320 else if (bIsSSIDEqual) {
2321
2322
2323
2324 if (bTSFLargeDiff && bTSFOffsetPostive) {
2325
2326
2327
2328
2329 memcpy(pMgmt->abyCurrBSSID, sFrame.pHdr->sA3.abyAddr3, WLAN_BSSID_LEN);
2330 memcpy(pDevice->abyBSSID, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
2331 pMgmt->wCurrATIMWindow = cpu_to_le16(sFrame.pIBSSParms->wATIMWindow);
2332 pMgmt->wCurrBeaconPeriod = cpu_to_le16(*sFrame.pwBeaconInterval);
2333 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
2334 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2335 WLAN_RATES_MAXLEN_11B);
2336
2337 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Rejoining to Other Adhoc group with same SSID........\n");
2338 VNSvOutPortW(pDevice->PortOffset + MAC_REG_BI, pMgmt->wCurrBeaconPeriod);
2339 CARDbUpdateTSF(pDevice, pRxPacket->byRxRate, qwTimestamp, qwLocalTSF);
2340 CARDvUpdateNextTBTT(pDevice->PortOffset, qwTimestamp, pMgmt->wCurrBeaconPeriod);
2341
2342 MACvWriteBSSIDAddress(pDevice->PortOffset, pMgmt->abyCurrBSSID);
2343
2344 CARDbSetPhyParameter ( pMgmt->pAdapter,
2345 pMgmt->eCurrentPHYMode,
2346 pMgmt->wCurrCapInfo,
2347 pMgmt->byERPContext,
2348 pMgmt->abyCurrSuppRates,
2349 pMgmt->abyCurrExtSuppRates);
2350
2351
2352
2353
2354
2355
2356 bMgrPrepareBeaconToSend((HANDLE)pDevice, pMgmt);
2357
2358 };
2359 }
2360 };
2361
2362
2363 if (bUpdateTSF) {
2364 CARDbGetCurrentTSF(pDevice->PortOffset, &qwCurrTSF);
2365 CARDbUpdateTSF(pDevice, pRxPacket->byRxRate, qwTimestamp, pRxPacket->qwLocalTSF);
2366 CARDbGetCurrentTSF(pDevice->PortOffset, &qwCurrTSF);
2367 CARDvUpdateNextTBTT(pDevice->PortOffset, qwTimestamp, pMgmt->wCurrBeaconPeriod);
2368 }
2369
2370 return;
2371}
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387VOID
2388vMgrCreateOwnIBSS(
2389 IN HANDLE hDeviceContext,
2390 OUT PCMD_STATUS pStatus
2391 )
2392{
2393 PSDevice pDevice = (PSDevice)hDeviceContext;
2394 PSMgmtObject pMgmt = pDevice->pMgmt;
2395 WORD wMaxBasicRate;
2396 WORD wMaxSuppRate;
2397 BYTE byTopCCKBasicRate;
2398 BYTE byTopOFDMBasicRate;
2399 QWORD qwCurrTSF;
2400 UINT ii;
2401 BYTE abyRATE[] = {0x82, 0x84, 0x8B, 0x96, 0x24, 0x30, 0x48, 0x6C, 0x0C, 0x12, 0x18, 0x60};
2402 BYTE abyCCK_RATE[] = {0x82, 0x84, 0x8B, 0x96};
2403 BYTE abyOFDM_RATE[] = {0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C};
2404 WORD wSuppRate;
2405
2406 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Create Basic Service Set .......\n");
2407
2408 if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
2409 if ((pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) &&
2410 (pDevice->eEncryptionStatus != Ndis802_11Encryption2Enabled) &&
2411 (pDevice->eEncryptionStatus != Ndis802_11Encryption3Enabled)) {
2412
2413 *pStatus = CMD_STATUS_FAILURE;
2414 return;
2415 }
2416 }
2417
2418 pMgmt->abyCurrSuppRates[0] = WLAN_EID_SUPP_RATES;
2419 pMgmt->abyCurrExtSuppRates[0] = WLAN_EID_EXTSUPP_RATES;
2420
2421 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2422 pMgmt->eCurrentPHYMode = pMgmt->byAPBBType;
2423 } else {
2424 if (pDevice->byBBType == BB_TYPE_11G)
2425 pMgmt->eCurrentPHYMode = PHY_TYPE_11G;
2426 if (pDevice->byBBType == BB_TYPE_11B)
2427 pMgmt->eCurrentPHYMode = PHY_TYPE_11B;
2428 if (pDevice->byBBType == BB_TYPE_11A)
2429 pMgmt->eCurrentPHYMode = PHY_TYPE_11A;
2430 }
2431
2432 if (pMgmt->eCurrentPHYMode != PHY_TYPE_11A) {
2433 pMgmt->abyCurrSuppRates[1] = WLAN_RATES_MAXLEN_11B;
2434 pMgmt->abyCurrExtSuppRates[1] = 0;
2435 for (ii = 0; ii < 4; ii++)
2436 pMgmt->abyCurrSuppRates[2+ii] = abyRATE[ii];
2437 } else {
2438 pMgmt->abyCurrSuppRates[1] = 8;
2439 pMgmt->abyCurrExtSuppRates[1] = 0;
2440 for (ii = 0; ii < 8; ii++)
2441 pMgmt->abyCurrSuppRates[2+ii] = abyRATE[ii];
2442 }
2443
2444
2445 if (pMgmt->eCurrentPHYMode == PHY_TYPE_11G) {
2446 pMgmt->abyCurrSuppRates[1] = 8;
2447 pMgmt->abyCurrExtSuppRates[1] = 4;
2448 for (ii = 0; ii < 4; ii++)
2449 pMgmt->abyCurrSuppRates[2+ii] = abyCCK_RATE[ii];
2450 for (ii = 4; ii < 8; ii++)
2451 pMgmt->abyCurrSuppRates[2+ii] = abyOFDM_RATE[ii-4];
2452 for (ii = 0; ii < 4; ii++)
2453 pMgmt->abyCurrExtSuppRates[2+ii] = abyOFDM_RATE[ii+4];
2454 }
2455
2456
2457
2458 pDevice->bProtectMode = 0;
2459 MACvDisableProtectMD(pDevice->PortOffset);
2460
2461 pDevice->bBarkerPreambleMd = 0;
2462 MACvDisableBarkerPreambleMd(pDevice->PortOffset);
2463
2464
2465
2466
2467 if (pMgmt->wIBSSBeaconPeriod == 0)
2468 pMgmt->wIBSSBeaconPeriod = DEFAULT_IBSS_BI;
2469
2470
2471 CARDbGetCurrentTSF(pDevice->PortOffset, &qwCurrTSF);
2472
2473 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
2474
2475 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
2476
2477
2478 CARDvSetFirstNextTBTT(pDevice->PortOffset, pMgmt->wIBSSBeaconPeriod);
2479
2480 pMgmt->uIBSSChannel = pDevice->uChannel;
2481
2482 if (pMgmt->uIBSSChannel == 0)
2483 pMgmt->uIBSSChannel = DEFAULT_IBSS_CHANNEL;
2484
2485
2486
2487
2488 RATEvParseMaxRate((PVOID)pDevice, (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2489 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates, TRUE,
2490 &wMaxBasicRate, &wMaxSuppRate, &wSuppRate,
2491 &byTopCCKBasicRate, &byTopOFDMBasicRate);
2492
2493
2494 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2495 pMgmt->eCurrMode = WMAC_MODE_ESS_AP;
2496 }
2497
2498 if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
2499 memcpy(pMgmt->abyIBSSDFSOwner, pDevice->abyCurrentNetAddr, 6);
2500 pMgmt->byIBSSDFSRecovery = 10;
2501 pMgmt->eCurrMode = WMAC_MODE_IBSS_STA;
2502 }
2503
2504
2505 pMgmt->eCurrState = WMAC_STATE_STARTED;
2506 pMgmt->wCurrBeaconPeriod = pMgmt->wIBSSBeaconPeriod;
2507 pMgmt->uCurrChannel = pMgmt->uIBSSChannel;
2508 pMgmt->wCurrATIMWindow = pMgmt->wIBSSATIMWindow;
2509 MACvWriteATIMW(pDevice->PortOffset, pMgmt->wCurrATIMWindow);
2510 pDevice->uCurrRSSI = 0;
2511 pDevice->byCurrSQ = 0;
2512
2513
2514 memset(pMgmt->abyCurrSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
2515 memcpy(pMgmt->abyCurrSSID,
2516 pMgmt->abyDesireSSID,
2517 ((PWLAN_IE_SSID)pMgmt->abyDesireSSID)->len + WLAN_IEHDR_LEN
2518 );
2519
2520 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2521
2522 memcpy(pMgmt->abyCurrBSSID, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
2523 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO"AP beacon created BSSID:%02x-%02x-%02x-%02x-%02x-%02x \n",
2524 pMgmt->abyCurrBSSID[0],
2525 pMgmt->abyCurrBSSID[1],
2526 pMgmt->abyCurrBSSID[2],
2527 pMgmt->abyCurrBSSID[3],
2528 pMgmt->abyCurrBSSID[4],
2529 pMgmt->abyCurrBSSID[5]
2530 );
2531 }
2532
2533 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2534
2535
2536 pMgmt->abyCurrBSSID[5] = (BYTE) (LODWORD(qwCurrTSF)& 0x000000ff);
2537 pMgmt->abyCurrBSSID[4] = (BYTE)((LODWORD(qwCurrTSF)& 0x0000ff00) >> 8);
2538 pMgmt->abyCurrBSSID[3] = (BYTE)((LODWORD(qwCurrTSF)& 0x00ff0000) >> 16);
2539 pMgmt->abyCurrBSSID[2] = (BYTE)((LODWORD(qwCurrTSF)& 0x00000ff0) >> 4);
2540 pMgmt->abyCurrBSSID[1] = (BYTE)((LODWORD(qwCurrTSF)& 0x000ff000) >> 12);
2541 pMgmt->abyCurrBSSID[0] = (BYTE)((LODWORD(qwCurrTSF)& 0x0ff00000) >> 20);
2542 pMgmt->abyCurrBSSID[5] ^= pMgmt->abyMACAddr[0];
2543 pMgmt->abyCurrBSSID[4] ^= pMgmt->abyMACAddr[1];
2544 pMgmt->abyCurrBSSID[3] ^= pMgmt->abyMACAddr[2];
2545 pMgmt->abyCurrBSSID[2] ^= pMgmt->abyMACAddr[3];
2546 pMgmt->abyCurrBSSID[1] ^= pMgmt->abyMACAddr[4];
2547 pMgmt->abyCurrBSSID[0] ^= pMgmt->abyMACAddr[5];
2548 pMgmt->abyCurrBSSID[0] &= ~IEEE_ADDR_GROUP;
2549 pMgmt->abyCurrBSSID[0] |= IEEE_ADDR_UNIVERSAL;
2550
2551
2552 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO"Adhoc beacon created bssid:%02x-%02x-%02x-%02x-%02x-%02x \n",
2553 pMgmt->abyCurrBSSID[0],
2554 pMgmt->abyCurrBSSID[1],
2555 pMgmt->abyCurrBSSID[2],
2556 pMgmt->abyCurrBSSID[3],
2557 pMgmt->abyCurrBSSID[4],
2558 pMgmt->abyCurrBSSID[5]
2559 );
2560 }
2561
2562
2563 pMgmt->wCurrCapInfo = 0;
2564
2565 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2566 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_ESS(1);
2567 pMgmt->byDTIMPeriod = DEFAULT_DTIM_PERIOD;
2568 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
2569 }
2570
2571 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2572 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_IBSS(1);
2573 }
2574
2575 if (pDevice->bEncryptionEnable) {
2576 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_PRIVACY(1);
2577 if (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) {
2578 if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2579 pMgmt->byCSSPK = KEY_CTL_CCMP;
2580 pMgmt->byCSSGK = KEY_CTL_CCMP;
2581 } else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2582 pMgmt->byCSSPK = KEY_CTL_TKIP;
2583 pMgmt->byCSSGK = KEY_CTL_TKIP;
2584 } else {
2585 pMgmt->byCSSPK = KEY_CTL_NONE;
2586 pMgmt->byCSSGK = KEY_CTL_WEP;
2587 }
2588 } else {
2589 pMgmt->byCSSPK = KEY_CTL_WEP;
2590 pMgmt->byCSSGK = KEY_CTL_WEP;
2591 }
2592 };
2593
2594 pMgmt->byERPContext = 0;
2595
2596
2597
2598 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2599 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_AP);
2600 } else {
2601 CARDbSetBSSID(pMgmt->pAdapter, pMgmt->abyCurrBSSID, OP_MODE_ADHOC);
2602 }
2603
2604 CARDbSetPhyParameter( pMgmt->pAdapter,
2605 pMgmt->eCurrentPHYMode,
2606 pMgmt->wCurrCapInfo,
2607 pMgmt->byERPContext,
2608 pMgmt->abyCurrSuppRates,
2609 pMgmt->abyCurrExtSuppRates
2610 );
2611
2612 CARDbSetBeaconPeriod(pMgmt->pAdapter, pMgmt->wIBSSBeaconPeriod);
2613
2614 CARDbSetChannel(pMgmt->pAdapter, pMgmt->uIBSSChannel);
2615 pMgmt->uCurrChannel = pMgmt->uIBSSChannel;
2616
2617 if (CARDbIsShortPreamble(pMgmt->pAdapter)) {
2618 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
2619 } else {
2620 pMgmt->wCurrCapInfo &= (~WLAN_SET_CAP_INFO_SHORTPREAMBLE(1));
2621 }
2622
2623 if ((pMgmt->b11hEnable == TRUE) &&
2624 (pMgmt->eCurrentPHYMode == PHY_TYPE_11A)) {
2625 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SPECTRUMMNG(1);
2626 } else {
2627 pMgmt->wCurrCapInfo &= (~WLAN_SET_CAP_INFO_SPECTRUMMNG(1));
2628 }
2629
2630 pMgmt->eCurrState = WMAC_STATE_STARTED;
2631
2632 if (bMgrPrepareBeaconToSend((HANDLE)pDevice, pMgmt)) {
2633 *pStatus = CMD_STATUS_SUCCESS;
2634 }
2635
2636 return ;
2637}
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654VOID
2655vMgrJoinBSSBegin(
2656 IN HANDLE hDeviceContext,
2657 OUT PCMD_STATUS pStatus
2658 )
2659{
2660
2661 PSDevice pDevice = (PSDevice)hDeviceContext;
2662 PSMgmtObject pMgmt = pDevice->pMgmt;
2663 PKnownBSS pCurr = NULL;
2664 UINT ii, uu;
2665 PWLAN_IE_SUPP_RATES pItemRates = NULL;
2666 PWLAN_IE_SUPP_RATES pItemExtRates = NULL;
2667 PWLAN_IE_SSID pItemSSID;
2668 UINT uRateLen = WLAN_RATES_MAXLEN;
2669 WORD wMaxBasicRate = RATE_1M;
2670 WORD wMaxSuppRate = RATE_1M;
2671 WORD wSuppRate;
2672 BYTE byTopCCKBasicRate = RATE_1M;
2673 BYTE byTopOFDMBasicRate = RATE_1M;
2674
2675
2676 for (ii = 0; ii < MAX_BSS_NUM; ii++) {
2677 if (pMgmt->sBSSList[ii].bActive == TRUE)
2678 break;
2679 }
2680
2681 if (ii == MAX_BSS_NUM) {
2682 *pStatus = CMD_STATUS_RESOURCES;
2683 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "BSS finding:BSS list is empty.\n");
2684 return;
2685 };
2686
2687
2688
2689
2690 pCurr = BSSpSearchBSSList(pDevice,
2691 pMgmt->abyDesireBSSID,
2692 pMgmt->abyDesireSSID,
2693 pMgmt->eConfigPHYMode
2694 );
2695
2696 if (pCurr == NULL){
2697 *pStatus = CMD_STATUS_RESOURCES;
2698 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
2699 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Scanning [%s] not found, disconnected !\n", pItemSSID->abySSID);
2700 return;
2701 };
2702
2703 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "AP(BSS) finding:Found a AP(BSS)..\n");
2704 if (WLAN_GET_CAP_INFO_ESS(cpu_to_le16(pCurr->wCapInfo))){
2705
2706 if ((pMgmt->eAuthenMode == WMAC_AUTH_WPA)||(pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK)) {
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726 }
2727
2728#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2729
2730 Encyption_Rebuild(pDevice, pCurr);
2731#endif
2732
2733 s_vMgrSynchBSS(pDevice,
2734 WMAC_MODE_ESS_STA,
2735 pCurr,
2736 pStatus
2737 );
2738
2739 if (*pStatus == CMD_STATUS_SUCCESS){
2740
2741
2742 pMgmt->uCurrChannel = pCurr->uChannel;
2743
2744 memset(pMgmt->abyCurrSuppRates, 0 , WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
2745 memset(pMgmt->abyCurrExtSuppRates, 0 , WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
2746
2747 if (pCurr->eNetworkTypeInUse == PHY_TYPE_11B) {
2748 uRateLen = WLAN_RATES_MAXLEN_11B;
2749 }
2750
2751 pItemRates = (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates;
2752 pItemExtRates = (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates;
2753
2754
2755 pItemRates->byElementID = WLAN_EID_SUPP_RATES;
2756 pItemRates->len = RATEuSetIE((PWLAN_IE_SUPP_RATES)pCurr->abySuppRates,
2757 pItemRates,
2758 uRateLen);
2759
2760
2761 pItemExtRates->byElementID = WLAN_EID_EXTSUPP_RATES;
2762 pItemExtRates->len = RATEuSetIE((PWLAN_IE_SUPP_RATES)pCurr->abyExtSuppRates,
2763 pItemExtRates,
2764 uRateLen);
2765
2766 if ((pItemExtRates->len > 0) && (pItemRates->len < 8)) {
2767 for (ii = 0; ii < (UINT)(8 - pItemRates->len); ) {
2768 pItemRates->abyRates[pItemRates->len + ii] = pItemExtRates->abyRates[ii];
2769 ii ++;
2770 if (pItemExtRates->len <= ii)
2771 break;
2772 }
2773 pItemRates->len += (BYTE)ii;
2774 if (pItemExtRates->len - ii > 0) {
2775 pItemExtRates->len -= (BYTE)ii;
2776 for (uu = 0; uu < pItemExtRates->len; uu ++) {
2777 pItemExtRates->abyRates[uu] = pItemExtRates->abyRates[uu + ii];
2778 }
2779 } else {
2780 pItemExtRates->len = 0;
2781 }
2782 }
2783
2784 RATEvParseMaxRate((PVOID)pDevice, pItemRates, pItemExtRates, TRUE,
2785 &wMaxBasicRate, &wMaxSuppRate, &wSuppRate,
2786 &byTopCCKBasicRate, &byTopOFDMBasicRate);
2787
2788
2789
2790 pMgmt->wCurrBeaconPeriod = pCurr->wBeaconInterval;
2791 memset(pMgmt->abyCurrSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
2792 memcpy(pMgmt->abyCurrBSSID, pCurr->abyBSSID, WLAN_BSSID_LEN);
2793 memcpy(pMgmt->abyCurrSSID, pCurr->abySSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
2794
2795 pMgmt->eCurrMode = WMAC_MODE_ESS_STA;
2796
2797 pMgmt->eCurrState = WMAC_STATE_JOINTED;
2798
2799
2800
2801
2802
2803
2804 if (pMgmt->eAuthenMode == WMAC_AUTH_WPA2) {
2805 BOOL bResult = bAdd_PMKID_Candidate((HANDLE)pDevice, pMgmt->abyCurrBSSID, &pCurr->sRSNCapObj);
2806 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"bAdd_PMKID_Candidate: 1(%d)\n", bResult);
2807 if (bResult == FALSE) {
2808 vFlush_PMKID_Candidate((HANDLE)pDevice);
2809 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFlush_PMKID_Candidate: 4\n");
2810 bAdd_PMKID_Candidate((HANDLE)pDevice, pMgmt->abyCurrBSSID, &pCurr->sRSNCapObj);
2811 }
2812 }
2813
2814
2815
2816
2817 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Join ESS\n");
2818
2819
2820
2821 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"End of Join AP -- A/B/G Action\n");
2822 }
2823 else {
2824 pMgmt->eCurrState = WMAC_STATE_IDLE;
2825 };
2826
2827
2828 }
2829 else {
2830
2831 if (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) {
2832
2833 if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2834 if (WPA_SearchRSN(0, WPA_TKIP, pCurr) == FALSE) {
2835
2836 pMgmt->eCurrState = WMAC_STATE_IDLE;
2837 return;
2838 }
2839 } else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2840 if (WPA_SearchRSN(0, WPA_AESCCMP, pCurr) == FALSE) {
2841
2842 pMgmt->eCurrState = WMAC_STATE_IDLE;
2843 return;
2844 }
2845 } else {
2846
2847 pMgmt->eCurrState = WMAC_STATE_IDLE;
2848 return;
2849 }
2850 }
2851
2852 s_vMgrSynchBSS(pDevice,
2853 WMAC_MODE_IBSS_STA,
2854 pCurr,
2855 pStatus
2856 );
2857
2858 if (*pStatus == CMD_STATUS_SUCCESS){
2859
2860
2861 pMgmt->uCurrChannel = pCurr->uChannel;
2862
2863
2864
2865 pMgmt->abyCurrSuppRates[0] = WLAN_EID_SUPP_RATES;
2866 pMgmt->abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)pCurr->abySuppRates,
2867 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2868 WLAN_RATES_MAXLEN_11B);
2869
2870 RATEvParseMaxRate((PVOID)pDevice, (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
2871 NULL, TRUE, &wMaxBasicRate, &wMaxSuppRate, &wSuppRate,
2872 &byTopCCKBasicRate, &byTopOFDMBasicRate);
2873
2874 pMgmt->wCurrCapInfo = pCurr->wCapInfo;
2875 pMgmt->wCurrBeaconPeriod = pCurr->wBeaconInterval;
2876 memset(pMgmt->abyCurrSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN);
2877 memcpy(pMgmt->abyCurrBSSID, pCurr->abyBSSID, WLAN_BSSID_LEN);
2878 memcpy(pMgmt->abyCurrSSID, pCurr->abySSID, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN);
2879
2880 MACvWriteATIMW(pDevice->PortOffset, pMgmt->wCurrATIMWindow);
2881 pMgmt->eCurrMode = WMAC_MODE_IBSS_STA;
2882
2883 pMgmt->eCurrState = WMAC_STATE_STARTED;
2884
2885
2886
2887
2888
2889 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Join IBSS ok:%02x-%02x-%02x-%02x-%02x-%02x \n",
2890 pMgmt->abyCurrBSSID[0],
2891 pMgmt->abyCurrBSSID[1],
2892 pMgmt->abyCurrBSSID[2],
2893 pMgmt->abyCurrBSSID[3],
2894 pMgmt->abyCurrBSSID[4],
2895 pMgmt->abyCurrBSSID[5]
2896 );
2897
2898
2899
2900
2901 bMgrPrepareBeaconToSend((HANDLE)pDevice, pMgmt);
2902 }
2903 else {
2904 pMgmt->eCurrState = WMAC_STATE_IDLE;
2905 };
2906 };
2907 return;
2908}
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922static
2923VOID
2924s_vMgrSynchBSS (
2925 IN PSDevice pDevice,
2926 IN UINT uBSSMode,
2927 IN PKnownBSS pCurr,
2928 OUT PCMD_STATUS pStatus
2929 )
2930{
2931 CARD_PHY_TYPE ePhyType = PHY_TYPE_11B;
2932 PSMgmtObject pMgmt = pDevice->pMgmt;
2933
2934
2935 BYTE abyCurrSuppRatesG[] = {WLAN_EID_SUPP_RATES, 8, 0x02, 0x04, 0x0B, 0x16, 0x24, 0x30, 0x48, 0x6C};
2936 BYTE abyCurrExtSuppRatesG[] = {WLAN_EID_EXTSUPP_RATES, 4, 0x0C, 0x12, 0x18, 0x60};
2937
2938 BYTE abyCurrSuppRatesA[] = {WLAN_EID_SUPP_RATES, 8, 0x0C, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C};
2939 BYTE abyCurrSuppRatesB[] = {WLAN_EID_SUPP_RATES, 4, 0x02, 0x04, 0x0B, 0x16};
2940
2941
2942 *pStatus = CMD_STATUS_FAILURE;
2943
2944 if (s_bCipherMatch(pCurr,
2945 pDevice->eEncryptionStatus,
2946 &(pMgmt->byCSSPK),
2947 &(pMgmt->byCSSGK)) == FALSE) {
2948 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "s_bCipherMatch Fail .......\n");
2949 return;
2950 }
2951
2952 pMgmt->pCurrBSS = pCurr;
2953
2954
2955 if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2956 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_BCNDMACTL, BEACON_READY);
2957 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX);
2958 }
2959
2960
2961 pDevice->bCCK = TRUE;
2962 pDevice->bProtectMode = FALSE;
2963 MACvDisableProtectMD(pDevice->PortOffset);
2964 pDevice->bBarkerPreambleMd = FALSE;
2965 MACvDisableBarkerPreambleMd(pDevice->PortOffset);
2966 pDevice->bNonERPPresent = FALSE;
2967 pDevice->byPreambleType = 0;
2968 pDevice->wBasicRate = 0;
2969
2970 CARDbAddBasicRate((PVOID)pDevice, RATE_1M);
2971
2972
2973 CARDbUpdateTSF(pDevice, pCurr->byRxRate, pCurr->qwBSSTimestamp, pCurr->qwLocalTSF);
2974
2975 CARDbSetBeaconPeriod(pDevice, pCurr->wBeaconInterval);
2976
2977
2978
2979 CARDvSetFirstNextTBTT(pDevice->PortOffset, pCurr->wBeaconInterval);
2980
2981
2982 MACvWriteBSSIDAddress(pDevice->PortOffset, pCurr->abyBSSID);
2983
2984 MACvReadBSSIDAddress(pDevice->PortOffset, pMgmt->abyCurrBSSID);
2985
2986 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Sync:set CurrBSSID address = %02x-%02x-%02x=%02x-%02x-%02x\n",
2987 pMgmt->abyCurrBSSID[0],
2988 pMgmt->abyCurrBSSID[1],
2989 pMgmt->abyCurrBSSID[2],
2990 pMgmt->abyCurrBSSID[3],
2991 pMgmt->abyCurrBSSID[4],
2992 pMgmt->abyCurrBSSID[5]);
2993
2994 if (pCurr->eNetworkTypeInUse == PHY_TYPE_11A) {
2995 if ((pMgmt->eConfigPHYMode == PHY_TYPE_11A) ||
2996 (pMgmt->eConfigPHYMode == PHY_TYPE_AUTO)) {
2997 ePhyType = PHY_TYPE_11A;
2998 } else {
2999 return;
3000 }
3001 } else if (pCurr->eNetworkTypeInUse == PHY_TYPE_11B) {
3002 if ((pMgmt->eConfigPHYMode == PHY_TYPE_11B) ||
3003 (pMgmt->eConfigPHYMode == PHY_TYPE_11G) ||
3004 (pMgmt->eConfigPHYMode == PHY_TYPE_AUTO)) {
3005 ePhyType = PHY_TYPE_11B;
3006 } else {
3007 return;
3008 }
3009 } else {
3010 if ((pMgmt->eConfigPHYMode == PHY_TYPE_11G) ||
3011 (pMgmt->eConfigPHYMode == PHY_TYPE_AUTO)) {
3012 ePhyType = PHY_TYPE_11G;
3013 } else if (pMgmt->eConfigPHYMode == PHY_TYPE_11B) {
3014 ePhyType = PHY_TYPE_11B;
3015 } else {
3016 return;
3017 }
3018 }
3019
3020 if (ePhyType == PHY_TYPE_11A) {
3021 memcpy(pMgmt->abyCurrSuppRates, &abyCurrSuppRatesA[0], sizeof(abyCurrSuppRatesA));
3022 pMgmt->abyCurrExtSuppRates[1] = 0;
3023 } else if (ePhyType == PHY_TYPE_11B) {
3024 memcpy(pMgmt->abyCurrSuppRates, &abyCurrSuppRatesB[0], sizeof(abyCurrSuppRatesB));
3025 pMgmt->abyCurrExtSuppRates[1] = 0;
3026 } else {
3027 memcpy(pMgmt->abyCurrSuppRates, &abyCurrSuppRatesG[0], sizeof(abyCurrSuppRatesG));
3028 memcpy(pMgmt->abyCurrExtSuppRates, &abyCurrExtSuppRatesG[0], sizeof(abyCurrExtSuppRatesG));
3029 }
3030
3031
3032 if (WLAN_GET_CAP_INFO_ESS(pCurr->wCapInfo)) {
3033 CARDbSetBSSID(pMgmt->pAdapter, pCurr->abyBSSID, OP_MODE_INFRASTRUCTURE);
3034
3035
3036 if (pMgmt->eAuthenMode == WMAC_AUTH_WPA2) {
3037 CARDbAdd_PMKID_Candidate(pMgmt->pAdapter, pMgmt->abyCurrBSSID, pCurr->sRSNCapObj.bRSNCapExist, pCurr->sRSNCapObj.wRSNCap);
3038 }
3039 } else {
3040 CARDbSetBSSID(pMgmt->pAdapter, pCurr->abyBSSID, OP_MODE_ADHOC);
3041 }
3042
3043 if (CARDbSetPhyParameter( pMgmt->pAdapter,
3044 ePhyType,
3045 pCurr->wCapInfo,
3046 pCurr->sERP.byERP,
3047 pMgmt->abyCurrSuppRates,
3048 pMgmt->abyCurrExtSuppRates
3049 ) != TRUE) {
3050 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "<----s_bSynchBSS Set Phy Mode Fail [%d]\n", ePhyType);
3051 return;
3052 }
3053
3054 if (CARDbSetChannel(pMgmt->pAdapter, pCurr->uChannel) == FALSE) {
3055 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "<----s_bSynchBSS Set Channel [%d]\n", pCurr->uChannel);
3056 return;
3057 }
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077 pMgmt->uCurrChannel = pCurr->uChannel;
3078 pMgmt->eCurrentPHYMode = ePhyType;
3079 pMgmt->byERPContext = pCurr->sERP.byERP;
3080 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Sync:Set to channel = [%d]\n", (INT)pCurr->uChannel);
3081
3082
3083 *pStatus = CMD_STATUS_SUCCESS;
3084
3085
3086 return;
3087};
3088
3089
3090
3091 static VOID Encyption_Rebuild(
3092 IN PSDevice pDevice,
3093 IN PKnownBSS pCurr
3094 )
3095 {
3096 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106 if ((pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK) ||
3107 (pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK)) {
3108 if(pCurr->bWPAValid == TRUE) {
3109 pMgmt->eAuthenMode = WMAC_AUTH_WPAPSK;
3110 if(pCurr->abyPKType[0] == WPA_TKIP) {
3111 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
3112 PRINT_K("Encyption_Rebuild--->ssid reset config to [WPAPSK-TKIP]\n");
3113 }
3114 else if(pCurr->abyPKType[0] == WPA_AESCCMP) {
3115 pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
3116 PRINT_K("Encyption_Rebuild--->ssid reset config to [WPAPSK-AES]\n");
3117 }
3118 }
3119 else if(pCurr->bWPA2Valid == TRUE) {
3120 pMgmt->eAuthenMode = WMAC_AUTH_WPA2PSK;
3121 if(pCurr->abyCSSPK[0] == WLAN_11i_CSS_TKIP) {
3122 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
3123 PRINT_K("Encyption_Rebuild--->ssid reset config to [WPA2PSK-TKIP]\n");
3124 }
3125 else if(pCurr->abyCSSPK[0] == WLAN_11i_CSS_CCMP) {
3126 pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
3127 PRINT_K("Encyption_Rebuild--->ssid reset config to [WPA2PSK-AES]\n");
3128 }
3129 }
3130 }
3131
3132 return;
3133 }
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147static
3148VOID
3149s_vMgrFormatTIM(
3150 IN PSMgmtObject pMgmt,
3151 IN PWLAN_IE_TIM pTIM
3152 )
3153{
3154 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
3155 BYTE byMap;
3156 UINT ii, jj;
3157 BOOL bStartFound = FALSE;
3158 BOOL bMulticast = FALSE;
3159 WORD wStartIndex = 0;
3160 WORD wEndIndex = 0;
3161
3162
3163
3164 for (ii = 0; ii < (MAX_NODE_NUM + 1); ii++) {
3165 byMap = pMgmt->abyPSTxMap[ii];
3166 if (!ii) {
3167
3168 bMulticast = (byMap & byMask[0]) != 0;
3169 if(bMulticast) {
3170 pMgmt->sNodeDBTable[0].bRxPSPoll = TRUE;
3171 }
3172 byMap = 0;
3173 }
3174 if (byMap) {
3175 if (!bStartFound) {
3176 bStartFound = TRUE;
3177 wStartIndex = ii;
3178 }
3179 wEndIndex = ii;
3180 }
3181 };
3182
3183
3184
3185 wStartIndex &= ~BIT0;
3186
3187
3188 wEndIndex = ((wEndIndex + 1) & ~BIT0);
3189
3190
3191
3192 pTIM->len = 3 + (wEndIndex - wStartIndex) + 1;
3193
3194
3195 pTIM->byDTIMCount = pMgmt->byDTIMCount;
3196 pTIM->byDTIMPeriod = pMgmt->byDTIMPeriod;
3197 pTIM->byBitMapCtl = (bMulticast ? TIM_MULTICAST_MASK : 0) |
3198 (((wStartIndex >> 1) << 1) & TIM_BITMAPOFFSET_MASK);
3199
3200
3201
3202 for (ii = wStartIndex, jj =0 ; ii <= wEndIndex; ii++, jj++) {
3203 pTIM->byVirtBitMap[jj] = pMgmt->abyPSTxMap[ii];
3204 }
3205
3206
3207 pTIM->byVirtBitMap[0] &= ~BIT0;
3208}
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222static
3223PSTxMgmtPacket
3224s_MgrMakeBeacon(
3225 IN PSDevice pDevice,
3226 IN PSMgmtObject pMgmt,
3227 IN WORD wCurrCapInfo,
3228 IN WORD wCurrBeaconPeriod,
3229 IN UINT uCurrChannel,
3230 IN WORD wCurrATIMWinodw,
3231 IN PWLAN_IE_SSID pCurrSSID,
3232 IN PBYTE pCurrBSSID,
3233 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
3234 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
3235 )
3236{
3237 PSTxMgmtPacket pTxPacket = NULL;
3238 WLAN_FR_BEACON sFrame;
3239 BYTE abyBroadcastAddr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3240 PBYTE pbyBuffer;
3241 UINT uLength = 0;
3242 PWLAN_IE_IBSS_DFS pIBSSDFS = NULL;
3243 UINT ii;
3244
3245
3246 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
3247 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_BEACON_FR_MAXLEN);
3248 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
3249
3250 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3251 sFrame.len = WLAN_BEACON_FR_MAXLEN;
3252 vMgrEncodeBeacon(&sFrame);
3253
3254 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
3255 (
3256 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
3257 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_BEACON)
3258 ));
3259
3260 if (pDevice->bEnablePSMode) {
3261 sFrame.pHdr->sA3.wFrameCtl |= cpu_to_le16((WORD)WLAN_SET_FC_PWRMGT(1));
3262 }
3263
3264 memcpy( sFrame.pHdr->sA3.abyAddr1, abyBroadcastAddr, WLAN_ADDR_LEN);
3265 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
3266 memcpy( sFrame.pHdr->sA3.abyAddr3, pCurrBSSID, WLAN_BSSID_LEN);
3267 *sFrame.pwBeaconInterval = cpu_to_le16(wCurrBeaconPeriod);
3268 *sFrame.pwCapInfo = cpu_to_le16(wCurrCapInfo);
3269
3270 sFrame.pSSID = (PWLAN_IE_SSID)(sFrame.pBuf + sFrame.len);
3271 sFrame.len += ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len + WLAN_IEHDR_LEN;
3272 memcpy(sFrame.pSSID,
3273 pCurrSSID,
3274 ((PWLAN_IE_SSID)pCurrSSID)->len + WLAN_IEHDR_LEN
3275 );
3276
3277 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3278 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN;
3279 memcpy(sFrame.pSuppRates,
3280 pCurrSuppRates,
3281 ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN
3282 );
3283
3284 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
3285 sFrame.pDSParms = (PWLAN_IE_DS_PARMS)(sFrame.pBuf + sFrame.len);
3286 sFrame.len += (1) + WLAN_IEHDR_LEN;
3287 sFrame.pDSParms->byElementID = WLAN_EID_DS_PARMS;
3288 sFrame.pDSParms->len = 1;
3289 sFrame.pDSParms->byCurrChannel = (BYTE)uCurrChannel;
3290 }
3291
3292 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
3293 sFrame.pTIM = (PWLAN_IE_TIM)(sFrame.pBuf + sFrame.len);
3294 sFrame.pTIM->byElementID = WLAN_EID_TIM;
3295 s_vMgrFormatTIM(pMgmt, sFrame.pTIM);
3296 sFrame.len += (WLAN_IEHDR_LEN + sFrame.pTIM->len);
3297 }
3298
3299 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3300
3301
3302 sFrame.pIBSSParms = (PWLAN_IE_IBSS_PARMS)(sFrame.pBuf + sFrame.len);
3303 sFrame.len += (2) + WLAN_IEHDR_LEN;
3304 sFrame.pIBSSParms->byElementID = WLAN_EID_IBSS_PARMS;
3305 sFrame.pIBSSParms->len = 2;
3306 sFrame.pIBSSParms->wATIMWindow = wCurrATIMWinodw;
3307 if (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) {
3308
3309 sFrame.pRSNWPA = (PWLAN_IE_RSN_EXT)(sFrame.pBuf + sFrame.len);
3310 sFrame.pRSNWPA->byElementID = WLAN_EID_RSN_WPA;
3311 sFrame.pRSNWPA->len = 12;
3312 sFrame.pRSNWPA->abyOUI[0] = 0x00;
3313 sFrame.pRSNWPA->abyOUI[1] = 0x50;
3314 sFrame.pRSNWPA->abyOUI[2] = 0xf2;
3315 sFrame.pRSNWPA->abyOUI[3] = 0x01;
3316 sFrame.pRSNWPA->wVersion = 1;
3317 sFrame.pRSNWPA->abyMulticast[0] = 0x00;
3318 sFrame.pRSNWPA->abyMulticast[1] = 0x50;
3319 sFrame.pRSNWPA->abyMulticast[2] = 0xf2;
3320 if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)
3321 sFrame.pRSNWPA->abyMulticast[3] = 0x04;
3322 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
3323 sFrame.pRSNWPA->abyMulticast[3] = 0x02;
3324 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled)
3325 sFrame.pRSNWPA->abyMulticast[3] = 0x01;
3326 else
3327 sFrame.pRSNWPA->abyMulticast[3] = 0x00;
3328
3329
3330 sFrame.pRSNWPA->wPKCount = 0;
3331
3332 *((PWORD)(sFrame.pBuf + sFrame.len + sFrame.pRSNWPA->len))=0;
3333 sFrame.pRSNWPA->len +=2;
3334
3335
3336 *((PWORD)(sFrame.pBuf + sFrame.len + sFrame.pRSNWPA->len))=0;
3337 sFrame.pRSNWPA->len +=2;
3338 sFrame.len += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
3339 }
3340 }
3341
3342 if ((pMgmt->b11hEnable == TRUE) &&
3343 (pMgmt->eCurrentPHYMode == PHY_TYPE_11A)) {
3344
3345 pbyBuffer = (PBYTE)(sFrame.pBuf + sFrame.len);
3346 CARDvSetCountryIE(pMgmt->pAdapter, pbyBuffer);
3347 CARDvSetCountryInfo(pMgmt->pAdapter, PHY_TYPE_11A, pbyBuffer);
3348 uLength += ((PWLAN_IE_COUNTRY) pbyBuffer)->len + WLAN_IEHDR_LEN;
3349 pbyBuffer += (((PWLAN_IE_COUNTRY) pbyBuffer)->len + WLAN_IEHDR_LEN);
3350
3351 ((PWLAN_IE_PW_CONST) pbyBuffer)->byElementID = WLAN_EID_PWR_CONSTRAINT;
3352 ((PWLAN_IE_PW_CONST) pbyBuffer)->len = 1;
3353 ((PWLAN_IE_PW_CONST) pbyBuffer)->byPower = 0;
3354 pbyBuffer += (1) + WLAN_IEHDR_LEN;
3355 uLength += (1) + WLAN_IEHDR_LEN;
3356 if (pMgmt->bSwitchChannel == TRUE) {
3357
3358 ((PWLAN_IE_CH_SW) pbyBuffer)->byElementID = WLAN_EID_CH_SWITCH;
3359 ((PWLAN_IE_CH_SW) pbyBuffer)->len = 3;
3360 ((PWLAN_IE_CH_SW) pbyBuffer)->byMode = 1;
3361 ((PWLAN_IE_CH_SW) pbyBuffer)->byChannel = CARDbyGetChannelNumber(pMgmt->pAdapter, pMgmt->byNewChannel);
3362 ((PWLAN_IE_CH_SW) pbyBuffer)->byCount = 0;
3363 pbyBuffer += (3) + WLAN_IEHDR_LEN;
3364 uLength += (3) + WLAN_IEHDR_LEN;
3365 }
3366
3367 ((PWLAN_IE_TPC_REP) pbyBuffer)->byElementID = WLAN_EID_TPC_REP;
3368 ((PWLAN_IE_TPC_REP) pbyBuffer)->len = 2;
3369 ((PWLAN_IE_TPC_REP) pbyBuffer)->byTxPower = CARDbyGetTransmitPower(pMgmt->pAdapter);
3370 ((PWLAN_IE_TPC_REP) pbyBuffer)->byLinkMargin = 0;
3371 pbyBuffer += (2) + WLAN_IEHDR_LEN;
3372 uLength += (2) + WLAN_IEHDR_LEN;
3373
3374 if (pMgmt->eCurrMode != WMAC_MODE_ESS_AP) {
3375 pIBSSDFS = (PWLAN_IE_IBSS_DFS) pbyBuffer;
3376 pIBSSDFS->byElementID = WLAN_EID_IBSS_DFS;
3377 pIBSSDFS->len = 7;
3378 memcpy( pIBSSDFS->abyDFSOwner,
3379 pMgmt->abyIBSSDFSOwner,
3380 6);
3381 pIBSSDFS->byDFSRecovery = pMgmt->byIBSSDFSRecovery;
3382 pbyBuffer += (7) + WLAN_IEHDR_LEN;
3383 uLength += (7) + WLAN_IEHDR_LEN;
3384 for(ii=CB_MAX_CHANNEL_24G+1; ii<=CB_MAX_CHANNEL; ii++ ) {
3385 if (CARDbGetChannelMapInfo(pMgmt->pAdapter, ii, pbyBuffer, pbyBuffer+1) == TRUE) {
3386 pbyBuffer += 2;
3387 uLength += 2;
3388 pIBSSDFS->len += 2;
3389 }
3390 }
3391 }
3392 sFrame.len += uLength;
3393 }
3394
3395 if (pMgmt->eCurrentPHYMode == PHY_TYPE_11G) {
3396 sFrame.pERP = (PWLAN_IE_ERP)(sFrame.pBuf + sFrame.len);
3397 sFrame.len += 1 + WLAN_IEHDR_LEN;
3398 sFrame.pERP->byElementID = WLAN_EID_ERP;
3399 sFrame.pERP->len = 1;
3400 sFrame.pERP->byContext = 0;
3401 if (pDevice->bProtectMode == TRUE)
3402 sFrame.pERP->byContext |= WLAN_EID_ERP_USE_PROTECTION;
3403 if (pDevice->bNonERPPresent == TRUE)
3404 sFrame.pERP->byContext |= WLAN_EID_ERP_NONERP_PRESENT;
3405 if (pDevice->bBarkerPreambleMd == TRUE)
3406 sFrame.pERP->byContext |= WLAN_EID_ERP_BARKER_MODE;
3407 }
3408 if (((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len != 0) {
3409 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3410 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
3411 memcpy(sFrame.pExtSuppRates,
3412 pCurrExtSuppRates,
3413 ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN
3414 );
3415 }
3416
3417 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) && (pDevice->bEnableHostapd == TRUE)) {
3418 if (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) {
3419 if (pMgmt->wWPAIELen != 0) {
3420 sFrame.pRSN = (PWLAN_IE_RSN)(sFrame.pBuf + sFrame.len);
3421 memcpy(sFrame.pRSN, pMgmt->abyWPAIE, pMgmt->wWPAIELen);
3422 sFrame.len += pMgmt->wWPAIELen;
3423 }
3424 }
3425 }
3426
3427
3428 pTxPacket->cbMPDULen = sFrame.len;
3429 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
3430
3431 return pTxPacket;
3432}
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452PSTxMgmtPacket
3453s_MgrMakeProbeResponse(
3454 IN PSDevice pDevice,
3455 IN PSMgmtObject pMgmt,
3456 IN WORD wCurrCapInfo,
3457 IN WORD wCurrBeaconPeriod,
3458 IN UINT uCurrChannel,
3459 IN WORD wCurrATIMWinodw,
3460 IN PBYTE pDstAddr,
3461 IN PWLAN_IE_SSID pCurrSSID,
3462 IN PBYTE pCurrBSSID,
3463 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
3464 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates,
3465 IN BYTE byPHYType
3466 )
3467{
3468 PSTxMgmtPacket pTxPacket = NULL;
3469 WLAN_FR_PROBERESP sFrame;
3470 PBYTE pbyBuffer;
3471 UINT uLength = 0;
3472 PWLAN_IE_IBSS_DFS pIBSSDFS = NULL;
3473 UINT ii;
3474
3475
3476 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
3477 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_PROBERESP_FR_MAXLEN);
3478 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
3479
3480 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3481 sFrame.len = WLAN_PROBERESP_FR_MAXLEN;
3482 vMgrEncodeProbeResponse(&sFrame);
3483
3484 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
3485 (
3486 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
3487 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_PROBERESP)
3488 ));
3489 memcpy( sFrame.pHdr->sA3.abyAddr1, pDstAddr, WLAN_ADDR_LEN);
3490 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
3491 memcpy( sFrame.pHdr->sA3.abyAddr3, pCurrBSSID, WLAN_BSSID_LEN);
3492 *sFrame.pwBeaconInterval = cpu_to_le16(wCurrBeaconPeriod);
3493 *sFrame.pwCapInfo = cpu_to_le16(wCurrCapInfo);
3494
3495 if (byPHYType == BB_TYPE_11B) {
3496 *sFrame.pwCapInfo &= cpu_to_le16((WORD)~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1)));
3497 }
3498
3499
3500 sFrame.pSSID = (PWLAN_IE_SSID)(sFrame.pBuf + sFrame.len);
3501 sFrame.len += ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len + WLAN_IEHDR_LEN;
3502 memcpy(sFrame.pSSID,
3503 pCurrSSID,
3504 ((PWLAN_IE_SSID)pCurrSSID)->len + WLAN_IEHDR_LEN
3505 );
3506
3507 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3508
3509 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN;
3510 memcpy(sFrame.pSuppRates,
3511 pCurrSuppRates,
3512 ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN
3513 );
3514
3515
3516 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
3517 sFrame.pDSParms = (PWLAN_IE_DS_PARMS)(sFrame.pBuf + sFrame.len);
3518 sFrame.len += (1) + WLAN_IEHDR_LEN;
3519 sFrame.pDSParms->byElementID = WLAN_EID_DS_PARMS;
3520 sFrame.pDSParms->len = 1;
3521 sFrame.pDSParms->byCurrChannel = (BYTE)uCurrChannel;
3522 }
3523
3524 if (pMgmt->eCurrMode != WMAC_MODE_ESS_AP) {
3525
3526 sFrame.pIBSSParms = (PWLAN_IE_IBSS_PARMS)(sFrame.pBuf + sFrame.len);
3527 sFrame.len += (2) + WLAN_IEHDR_LEN;
3528 sFrame.pIBSSParms->byElementID = WLAN_EID_IBSS_PARMS;
3529 sFrame.pIBSSParms->len = 2;
3530 sFrame.pIBSSParms->wATIMWindow = 0;
3531 }
3532 if (pDevice->eCurrentPHYType == PHY_TYPE_11G) {
3533 sFrame.pERP = (PWLAN_IE_ERP)(sFrame.pBuf + sFrame.len);
3534 sFrame.len += 1 + WLAN_IEHDR_LEN;
3535 sFrame.pERP->byElementID = WLAN_EID_ERP;
3536 sFrame.pERP->len = 1;
3537 sFrame.pERP->byContext = 0;
3538 if (pDevice->bProtectMode == TRUE)
3539 sFrame.pERP->byContext |= WLAN_EID_ERP_USE_PROTECTION;
3540 if (pDevice->bNonERPPresent == TRUE)
3541 sFrame.pERP->byContext |= WLAN_EID_ERP_NONERP_PRESENT;
3542 if (pDevice->bBarkerPreambleMd == TRUE)
3543 sFrame.pERP->byContext |= WLAN_EID_ERP_BARKER_MODE;
3544 }
3545
3546 if ((pMgmt->b11hEnable == TRUE) &&
3547 (pMgmt->eCurrentPHYMode == PHY_TYPE_11A)) {
3548
3549 pbyBuffer = (PBYTE)(sFrame.pBuf + sFrame.len);
3550 CARDvSetCountryIE(pMgmt->pAdapter, pbyBuffer);
3551 CARDvSetCountryInfo(pMgmt->pAdapter, PHY_TYPE_11A, pbyBuffer);
3552 uLength += ((PWLAN_IE_COUNTRY) pbyBuffer)->len + WLAN_IEHDR_LEN;
3553 pbyBuffer += (((PWLAN_IE_COUNTRY) pbyBuffer)->len + WLAN_IEHDR_LEN);
3554
3555 ((PWLAN_IE_PW_CONST) pbyBuffer)->byElementID = WLAN_EID_PWR_CONSTRAINT;
3556 ((PWLAN_IE_PW_CONST) pbyBuffer)->len = 1;
3557 ((PWLAN_IE_PW_CONST) pbyBuffer)->byPower = 0;
3558 pbyBuffer += (1) + WLAN_IEHDR_LEN;
3559 uLength += (1) + WLAN_IEHDR_LEN;
3560 if (pMgmt->bSwitchChannel == TRUE) {
3561
3562 ((PWLAN_IE_CH_SW) pbyBuffer)->byElementID = WLAN_EID_CH_SWITCH;
3563 ((PWLAN_IE_CH_SW) pbyBuffer)->len = 3;
3564 ((PWLAN_IE_CH_SW) pbyBuffer)->byMode = 1;
3565 ((PWLAN_IE_CH_SW) pbyBuffer)->byChannel = CARDbyGetChannelNumber(pMgmt->pAdapter, pMgmt->byNewChannel);
3566 ((PWLAN_IE_CH_SW) pbyBuffer)->byCount = 0;
3567 pbyBuffer += (3) + WLAN_IEHDR_LEN;
3568 uLength += (3) + WLAN_IEHDR_LEN;
3569 }
3570
3571 ((PWLAN_IE_TPC_REP) pbyBuffer)->byElementID = WLAN_EID_TPC_REP;
3572 ((PWLAN_IE_TPC_REP) pbyBuffer)->len = 2;
3573 ((PWLAN_IE_TPC_REP) pbyBuffer)->byTxPower = CARDbyGetTransmitPower(pMgmt->pAdapter);
3574 ((PWLAN_IE_TPC_REP) pbyBuffer)->byLinkMargin = 0;
3575 pbyBuffer += (2) + WLAN_IEHDR_LEN;
3576 uLength += (2) + WLAN_IEHDR_LEN;
3577
3578 if (pMgmt->eCurrMode != WMAC_MODE_ESS_AP) {
3579 pIBSSDFS = (PWLAN_IE_IBSS_DFS) pbyBuffer;
3580 pIBSSDFS->byElementID = WLAN_EID_IBSS_DFS;
3581 pIBSSDFS->len = 7;
3582 memcpy( pIBSSDFS->abyDFSOwner,
3583 pMgmt->abyIBSSDFSOwner,
3584 6);
3585 pIBSSDFS->byDFSRecovery = pMgmt->byIBSSDFSRecovery;
3586 pbyBuffer += (7) + WLAN_IEHDR_LEN;
3587 uLength += (7) + WLAN_IEHDR_LEN;
3588 for(ii=CB_MAX_CHANNEL_24G+1; ii<=CB_MAX_CHANNEL; ii++ ) {
3589 if (CARDbGetChannelMapInfo(pMgmt->pAdapter, ii, pbyBuffer, pbyBuffer+1) == TRUE) {
3590 pbyBuffer += 2;
3591 uLength += 2;
3592 pIBSSDFS->len += 2;
3593 }
3594 }
3595 }
3596 sFrame.len += uLength;
3597 }
3598
3599
3600 if (((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len != 0) {
3601 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3602 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
3603 memcpy(sFrame.pExtSuppRates,
3604 pCurrExtSuppRates,
3605 ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN
3606 );
3607 }
3608
3609
3610 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) && (pDevice->bEnableHostapd == TRUE)) {
3611 if (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) {
3612 if (pMgmt->wWPAIELen != 0) {
3613 sFrame.pRSN = (PWLAN_IE_RSN)(sFrame.pBuf + sFrame.len);
3614 memcpy(sFrame.pRSN, pMgmt->abyWPAIE, pMgmt->wWPAIELen);
3615 sFrame.len += pMgmt->wWPAIELen;
3616 }
3617 }
3618 }
3619
3620
3621 pTxPacket->cbMPDULen = sFrame.len;
3622 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
3623
3624 return pTxPacket;
3625}
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641PSTxMgmtPacket
3642s_MgrMakeAssocRequest(
3643 IN PSDevice pDevice,
3644 IN PSMgmtObject pMgmt,
3645 IN PBYTE pDAddr,
3646 IN WORD wCurrCapInfo,
3647 IN WORD wListenInterval,
3648 IN PWLAN_IE_SSID pCurrSSID,
3649 IN PWLAN_IE_SUPP_RATES pCurrRates,
3650 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
3651 )
3652{
3653 PSTxMgmtPacket pTxPacket = NULL;
3654 WLAN_FR_ASSOCREQ sFrame;
3655 PBYTE pbyIEs;
3656 PBYTE pbyRSN;
3657
3658
3659 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
3660 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_ASSOCREQ_FR_MAXLEN);
3661 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
3662
3663 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3664 sFrame.len = WLAN_ASSOCREQ_FR_MAXLEN;
3665
3666 vMgrEncodeAssocRequest(&sFrame);
3667
3668 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
3669 (
3670 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
3671 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_ASSOCREQ)
3672 ));
3673 memcpy( sFrame.pHdr->sA3.abyAddr1, pDAddr, WLAN_ADDR_LEN);
3674 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
3675 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
3676
3677
3678 *(sFrame.pwCapInfo) = cpu_to_le16(wCurrCapInfo);
3679 *(sFrame.pwListenInterval) = cpu_to_le16(wListenInterval);
3680
3681
3682 sFrame.pSSID = (PWLAN_IE_SSID)(sFrame.pBuf + sFrame.len);
3683 sFrame.len += pCurrSSID->len + WLAN_IEHDR_LEN;
3684 memcpy(sFrame.pSSID, pCurrSSID, pCurrSSID->len + WLAN_IEHDR_LEN);
3685
3686 pMgmt->sAssocInfo.AssocInfo.RequestIELength = pCurrSSID->len + WLAN_IEHDR_LEN;
3687 pMgmt->sAssocInfo.AssocInfo.OffsetRequestIEs = sizeof(NDIS_802_11_ASSOCIATION_INFORMATION);
3688 pbyIEs = pMgmt->sAssocInfo.abyIEs;
3689 memcpy(pbyIEs, pCurrSSID, pCurrSSID->len + WLAN_IEHDR_LEN);
3690 pbyIEs += pCurrSSID->len + WLAN_IEHDR_LEN;
3691
3692
3693 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3694 if ((pDevice->eCurrentPHYType == PHY_TYPE_11B) && (pCurrRates->len > 4))
3695 sFrame.len += 4 + WLAN_IEHDR_LEN;
3696 else
3697 sFrame.len += pCurrRates->len + WLAN_IEHDR_LEN;
3698 memcpy(sFrame.pSuppRates, pCurrRates, pCurrRates->len + WLAN_IEHDR_LEN);
3699
3700
3701 if ((pDevice->eCurrentPHYType == PHY_TYPE_11G) && (pCurrExtSuppRates->len > 0)) {
3702 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3703 sFrame.len += pCurrExtSuppRates->len + WLAN_IEHDR_LEN;
3704 memcpy(sFrame.pExtSuppRates, pCurrExtSuppRates, pCurrExtSuppRates->len + WLAN_IEHDR_LEN);
3705 }
3706
3707 pMgmt->sAssocInfo.AssocInfo.RequestIELength += pCurrRates->len + WLAN_IEHDR_LEN;
3708 memcpy(pbyIEs, pCurrRates, pCurrRates->len + WLAN_IEHDR_LEN);
3709 pbyIEs += pCurrRates->len + WLAN_IEHDR_LEN;
3710
3711
3712 if (pMgmt->b11hEnable == TRUE) {
3713 if (sFrame.pCurrPowerCap == NULL) {
3714 sFrame.pCurrPowerCap = (PWLAN_IE_PW_CAP)(sFrame.pBuf + sFrame.len);
3715 sFrame.len += (2 + WLAN_IEHDR_LEN);
3716 sFrame.pCurrPowerCap->byElementID = WLAN_EID_PWR_CAPABILITY;
3717 sFrame.pCurrPowerCap->len = 2;
3718 CARDvGetPowerCapability(pMgmt->pAdapter,
3719 &(sFrame.pCurrPowerCap->byMinPower),
3720 &(sFrame.pCurrPowerCap->byMaxPower)
3721 );
3722 }
3723 if (sFrame.pCurrSuppCh == NULL) {
3724 sFrame.pCurrSuppCh = (PWLAN_IE_SUPP_CH)(sFrame.pBuf + sFrame.len);
3725 sFrame.len += CARDbySetSupportChannels(pMgmt->pAdapter,(PBYTE)sFrame.pCurrSuppCh);
3726 }
3727 }
3728
3729 if (((pMgmt->eAuthenMode == WMAC_AUTH_WPA) ||
3730 (pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK) ||
3731 (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE)) &&
3732 (pMgmt->pCurrBSS != NULL)) {
3733
3734 sFrame.pRSNWPA = (PWLAN_IE_RSN_EXT)(sFrame.pBuf + sFrame.len);
3735 sFrame.pRSNWPA->byElementID = WLAN_EID_RSN_WPA;
3736 sFrame.pRSNWPA->len = 16;
3737 sFrame.pRSNWPA->abyOUI[0] = 0x00;
3738 sFrame.pRSNWPA->abyOUI[1] = 0x50;
3739 sFrame.pRSNWPA->abyOUI[2] = 0xf2;
3740 sFrame.pRSNWPA->abyOUI[3] = 0x01;
3741 sFrame.pRSNWPA->wVersion = 1;
3742
3743 sFrame.pRSNWPA->abyMulticast[0] = 0x00;
3744 sFrame.pRSNWPA->abyMulticast[1] = 0x50;
3745 sFrame.pRSNWPA->abyMulticast[2] = 0xf2;
3746 if (pMgmt->byCSSGK == KEY_CTL_WEP) {
3747 sFrame.pRSNWPA->abyMulticast[3] = pMgmt->pCurrBSS->byGKType;
3748 } else if (pMgmt->byCSSGK == KEY_CTL_TKIP) {
3749 sFrame.pRSNWPA->abyMulticast[3] = WPA_TKIP;
3750 } else if (pMgmt->byCSSGK == KEY_CTL_CCMP) {
3751 sFrame.pRSNWPA->abyMulticast[3] = WPA_AESCCMP;
3752 } else {
3753 sFrame.pRSNWPA->abyMulticast[3] = WPA_NONE;
3754 }
3755
3756 sFrame.pRSNWPA->wPKCount = 1;
3757 sFrame.pRSNWPA->PKSList[0].abyOUI[0] = 0x00;
3758 sFrame.pRSNWPA->PKSList[0].abyOUI[1] = 0x50;
3759 sFrame.pRSNWPA->PKSList[0].abyOUI[2] = 0xf2;
3760 if (pMgmt->byCSSPK == KEY_CTL_TKIP) {
3761 sFrame.pRSNWPA->PKSList[0].abyOUI[3] = WPA_TKIP;
3762 } else if (pMgmt->byCSSPK == KEY_CTL_CCMP) {
3763 sFrame.pRSNWPA->PKSList[0].abyOUI[3] = WPA_AESCCMP;
3764 } else {
3765 sFrame.pRSNWPA->PKSList[0].abyOUI[3] = WPA_NONE;
3766 }
3767
3768 pbyRSN = (PBYTE)(sFrame.pBuf + sFrame.len + 2 + sFrame.pRSNWPA->len);
3769 *pbyRSN++=0x01;
3770 *pbyRSN++=0x00;
3771 *pbyRSN++=0x00;
3772
3773 *pbyRSN++=0x50;
3774 *pbyRSN++=0xf2;
3775 if (pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK) {
3776 *pbyRSN++=WPA_AUTH_PSK;
3777 }
3778 else if (pMgmt->eAuthenMode == WMAC_AUTH_WPA) {
3779 *pbyRSN++=WPA_AUTH_IEEE802_1X;
3780 }
3781 else {
3782 *pbyRSN++=WPA_NONE;
3783 }
3784
3785 sFrame.pRSNWPA->len +=6;
3786
3787
3788
3789 *pbyRSN++=0x00;
3790 *pbyRSN++=0x00;
3791 sFrame.pRSNWPA->len +=2;
3792
3793 sFrame.len += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
3794
3795 pMgmt->sAssocInfo.AssocInfo.RequestIELength += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
3796 memcpy(pbyIEs, sFrame.pRSNWPA, sFrame.pRSNWPA->len + WLAN_IEHDR_LEN);
3797 pbyIEs += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
3798
3799 } else if (((pMgmt->eAuthenMode == WMAC_AUTH_WPA2) ||
3800 (pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK)) &&
3801 (pMgmt->pCurrBSS != NULL)) {
3802 UINT ii;
3803 PWORD pwPMKID;
3804
3805
3806 sFrame.pRSN = (PWLAN_IE_RSN)(sFrame.pBuf + sFrame.len);
3807 sFrame.pRSN->byElementID = WLAN_EID_RSN;
3808 sFrame.pRSN->len = 6;
3809 sFrame.pRSN->wVersion = 1;
3810
3811 sFrame.pRSN->abyRSN[0] = 0x00;
3812 sFrame.pRSN->abyRSN[1] = 0x0F;
3813 sFrame.pRSN->abyRSN[2] = 0xAC;
3814 if (pMgmt->byCSSGK == KEY_CTL_WEP) {
3815 sFrame.pRSN->abyRSN[3] = pMgmt->pCurrBSS->byCSSGK;
3816 } else if (pMgmt->byCSSGK == KEY_CTL_TKIP) {
3817 sFrame.pRSN->abyRSN[3] = WLAN_11i_CSS_TKIP;
3818 } else if (pMgmt->byCSSGK == KEY_CTL_CCMP) {
3819 sFrame.pRSN->abyRSN[3] = WLAN_11i_CSS_CCMP;
3820 } else {
3821 sFrame.pRSN->abyRSN[3] = WLAN_11i_CSS_UNKNOWN;
3822 }
3823
3824
3825 sFrame.pRSN->abyRSN[4] = 1;
3826 sFrame.pRSN->abyRSN[5] = 0;
3827 sFrame.pRSN->abyRSN[6] = 0x00;
3828 sFrame.pRSN->abyRSN[7] = 0x0F;
3829 sFrame.pRSN->abyRSN[8] = 0xAC;
3830 if (pMgmt->byCSSPK == KEY_CTL_TKIP) {
3831 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_TKIP;
3832 } else if (pMgmt->byCSSPK == KEY_CTL_CCMP) {
3833 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_CCMP;
3834 } else if (pMgmt->byCSSPK == KEY_CTL_NONE) {
3835 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_USE_GROUP;
3836 } else {
3837 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_UNKNOWN;
3838 }
3839 sFrame.pRSN->len += 6;
3840
3841
3842 sFrame.pRSN->abyRSN[10] = 1;
3843 sFrame.pRSN->abyRSN[11] = 0;
3844 sFrame.pRSN->abyRSN[12] = 0x00;
3845 sFrame.pRSN->abyRSN[13] = 0x0F;
3846 sFrame.pRSN->abyRSN[14] = 0xAC;
3847 if (pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK) {
3848 sFrame.pRSN->abyRSN[15] = WLAN_11i_AKMSS_PSK;
3849 } else if (pMgmt->eAuthenMode == WMAC_AUTH_WPA2) {
3850 sFrame.pRSN->abyRSN[15] = WLAN_11i_AKMSS_802_1X;
3851 } else {
3852 sFrame.pRSN->abyRSN[15] = WLAN_11i_AKMSS_UNKNOWN;
3853 }
3854 sFrame.pRSN->len +=6;
3855
3856
3857 if (pMgmt->pCurrBSS->sRSNCapObj.bRSNCapExist == TRUE) {
3858 memcpy(&sFrame.pRSN->abyRSN[16], &pMgmt->pCurrBSS->sRSNCapObj.wRSNCap, 2);
3859 } else {
3860 sFrame.pRSN->abyRSN[16] = 0;
3861 sFrame.pRSN->abyRSN[17] = 0;
3862 }
3863 sFrame.pRSN->len +=2;
3864
3865 if ((pDevice->gsPMKID.BSSIDInfoCount > 0) && (pDevice->bRoaming == TRUE) && (pMgmt->eAuthenMode == WMAC_AUTH_WPA2)) {
3866
3867 pbyRSN = &sFrame.pRSN->abyRSN[18];
3868 pwPMKID = (PWORD)pbyRSN;
3869 *pwPMKID = 0;
3870 pbyRSN += 2;
3871 for (ii = 0; ii < pDevice->gsPMKID.BSSIDInfoCount; ii++) {
3872 if ( !memcmp(&pDevice->gsPMKID.BSSIDInfo[ii].BSSID[0], pMgmt->abyCurrBSSID, U_ETHER_ADDR_LEN)) {
3873 (*pwPMKID) ++;
3874 memcpy(pbyRSN, pDevice->gsPMKID.BSSIDInfo[ii].PMKID, 16);
3875 pbyRSN += 16;
3876 }
3877 }
3878 if (*pwPMKID != 0) {
3879 sFrame.pRSN->len += (2 + (*pwPMKID)*16);
3880 }
3881 }
3882
3883 sFrame.len += sFrame.pRSN->len + WLAN_IEHDR_LEN;
3884
3885 pMgmt->sAssocInfo.AssocInfo.RequestIELength += sFrame.pRSN->len + WLAN_IEHDR_LEN;
3886 memcpy(pbyIEs, sFrame.pRSN, sFrame.pRSN->len + WLAN_IEHDR_LEN);
3887 pbyIEs += sFrame.pRSN->len + WLAN_IEHDR_LEN;
3888 }
3889
3890
3891
3892 pTxPacket->cbMPDULen = sFrame.len;
3893 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
3894 return pTxPacket;
3895}
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916PSTxMgmtPacket
3917s_MgrMakeReAssocRequest(
3918 IN PSDevice pDevice,
3919 IN PSMgmtObject pMgmt,
3920 IN PBYTE pDAddr,
3921 IN WORD wCurrCapInfo,
3922 IN WORD wListenInterval,
3923 IN PWLAN_IE_SSID pCurrSSID,
3924 IN PWLAN_IE_SUPP_RATES pCurrRates,
3925 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
3926 )
3927{
3928 PSTxMgmtPacket pTxPacket = NULL;
3929 WLAN_FR_REASSOCREQ sFrame;
3930 PBYTE pbyIEs;
3931 PBYTE pbyRSN;
3932
3933
3934 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
3935 memset( pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_REASSOCREQ_FR_MAXLEN);
3936 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
3937
3938 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3939 sFrame.len = WLAN_REASSOCREQ_FR_MAXLEN;
3940
3941
3942 vMgrEncodeReassocRequest(&sFrame);
3943
3944
3945 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
3946 (
3947 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
3948 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_REASSOCREQ)
3949 ));
3950 memcpy( sFrame.pHdr->sA3.abyAddr1, pDAddr, WLAN_ADDR_LEN);
3951 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
3952 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
3953
3954
3955 *(sFrame.pwCapInfo) = cpu_to_le16(wCurrCapInfo);
3956 *(sFrame.pwListenInterval) = cpu_to_le16(wListenInterval);
3957
3958 memcpy(sFrame.pAddrCurrAP, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
3959
3960
3961 sFrame.pSSID = (PWLAN_IE_SSID)(sFrame.pBuf + sFrame.len);
3962 sFrame.len += pCurrSSID->len + WLAN_IEHDR_LEN;
3963 memcpy(sFrame.pSSID, pCurrSSID, pCurrSSID->len + WLAN_IEHDR_LEN);
3964
3965 pMgmt->sAssocInfo.AssocInfo.RequestIELength = pCurrSSID->len + WLAN_IEHDR_LEN;
3966 pMgmt->sAssocInfo.AssocInfo.OffsetRequestIEs = sizeof(NDIS_802_11_ASSOCIATION_INFORMATION);
3967 pbyIEs = pMgmt->sAssocInfo.abyIEs;
3968 memcpy(pbyIEs, pCurrSSID, pCurrSSID->len + WLAN_IEHDR_LEN);
3969 pbyIEs += pCurrSSID->len + WLAN_IEHDR_LEN;
3970
3971
3972
3973 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3974 sFrame.len += pCurrRates->len + WLAN_IEHDR_LEN;
3975 memcpy(sFrame.pSuppRates, pCurrRates, pCurrRates->len + WLAN_IEHDR_LEN);
3976
3977
3978 if ((pMgmt->eCurrentPHYMode == PHY_TYPE_11G) && (pCurrExtSuppRates->len > 0)) {
3979 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
3980 sFrame.len += pCurrExtSuppRates->len + WLAN_IEHDR_LEN;
3981 memcpy(sFrame.pExtSuppRates, pCurrExtSuppRates, pCurrExtSuppRates->len + WLAN_IEHDR_LEN);
3982 }
3983
3984 pMgmt->sAssocInfo.AssocInfo.RequestIELength += pCurrRates->len + WLAN_IEHDR_LEN;
3985 memcpy(pbyIEs, pCurrRates, pCurrRates->len + WLAN_IEHDR_LEN);
3986 pbyIEs += pCurrRates->len + WLAN_IEHDR_LEN;
3987
3988 if (((pMgmt->eAuthenMode == WMAC_AUTH_WPA) ||
3989 (pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK) ||
3990 (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE)) &&
3991 (pMgmt->pCurrBSS != NULL)) {
3992
3993 sFrame.pRSNWPA = (PWLAN_IE_RSN_EXT)(sFrame.pBuf + sFrame.len);
3994 sFrame.pRSNWPA->byElementID = WLAN_EID_RSN_WPA;
3995 sFrame.pRSNWPA->len = 16;
3996 sFrame.pRSNWPA->abyOUI[0] = 0x00;
3997 sFrame.pRSNWPA->abyOUI[1] = 0x50;
3998 sFrame.pRSNWPA->abyOUI[2] = 0xf2;
3999 sFrame.pRSNWPA->abyOUI[3] = 0x01;
4000 sFrame.pRSNWPA->wVersion = 1;
4001
4002 sFrame.pRSNWPA->abyMulticast[0] = 0x00;
4003 sFrame.pRSNWPA->abyMulticast[1] = 0x50;
4004 sFrame.pRSNWPA->abyMulticast[2] = 0xf2;
4005 if (pMgmt->byCSSGK == KEY_CTL_WEP) {
4006 sFrame.pRSNWPA->abyMulticast[3] = pMgmt->pCurrBSS->byGKType;
4007 } else if (pMgmt->byCSSGK == KEY_CTL_TKIP) {
4008 sFrame.pRSNWPA->abyMulticast[3] = WPA_TKIP;
4009 } else if (pMgmt->byCSSGK == KEY_CTL_CCMP) {
4010 sFrame.pRSNWPA->abyMulticast[3] = WPA_AESCCMP;
4011 } else {
4012 sFrame.pRSNWPA->abyMulticast[3] = WPA_NONE;
4013 }
4014
4015 sFrame.pRSNWPA->wPKCount = 1;
4016 sFrame.pRSNWPA->PKSList[0].abyOUI[0] = 0x00;
4017 sFrame.pRSNWPA->PKSList[0].abyOUI[1] = 0x50;
4018 sFrame.pRSNWPA->PKSList[0].abyOUI[2] = 0xf2;
4019 if (pMgmt->byCSSPK == KEY_CTL_TKIP) {
4020 sFrame.pRSNWPA->PKSList[0].abyOUI[3] = WPA_TKIP;
4021 } else if (pMgmt->byCSSPK == KEY_CTL_CCMP) {
4022 sFrame.pRSNWPA->PKSList[0].abyOUI[3] = WPA_AESCCMP;
4023 } else {
4024 sFrame.pRSNWPA->PKSList[0].abyOUI[3] = WPA_NONE;
4025 }
4026
4027 pbyRSN = (PBYTE)(sFrame.pBuf + sFrame.len + 2 + sFrame.pRSNWPA->len);
4028 *pbyRSN++=0x01;
4029 *pbyRSN++=0x00;
4030 *pbyRSN++=0x00;
4031
4032 *pbyRSN++=0x50;
4033 *pbyRSN++=0xf2;
4034 if (pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK) {
4035 *pbyRSN++=WPA_AUTH_PSK;
4036 } else if (pMgmt->eAuthenMode == WMAC_AUTH_WPA) {
4037 *pbyRSN++=WPA_AUTH_IEEE802_1X;
4038 } else {
4039 *pbyRSN++=WPA_NONE;
4040 }
4041
4042 sFrame.pRSNWPA->len +=6;
4043
4044
4045 *pbyRSN++=0x00;
4046 *pbyRSN++=0x00;
4047 sFrame.pRSNWPA->len +=2;
4048
4049 sFrame.len += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
4050
4051 pMgmt->sAssocInfo.AssocInfo.RequestIELength += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
4052 memcpy(pbyIEs, sFrame.pRSNWPA, sFrame.pRSNWPA->len + WLAN_IEHDR_LEN);
4053 pbyIEs += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
4054
4055 } else if (((pMgmt->eAuthenMode == WMAC_AUTH_WPA2) ||
4056 (pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK)) &&
4057 (pMgmt->pCurrBSS != NULL)) {
4058 UINT ii;
4059 PWORD pwPMKID;
4060
4061
4062 sFrame.pRSN = (PWLAN_IE_RSN)(sFrame.pBuf + sFrame.len);
4063 sFrame.pRSN->byElementID = WLAN_EID_RSN;
4064 sFrame.pRSN->len = 6;
4065 sFrame.pRSN->wVersion = 1;
4066
4067 sFrame.pRSN->abyRSN[0] = 0x00;
4068 sFrame.pRSN->abyRSN[1] = 0x0F;
4069 sFrame.pRSN->abyRSN[2] = 0xAC;
4070 if (pMgmt->byCSSGK == KEY_CTL_WEP) {
4071 sFrame.pRSN->abyRSN[3] = pMgmt->pCurrBSS->byCSSGK;
4072 } else if (pMgmt->byCSSGK == KEY_CTL_TKIP) {
4073 sFrame.pRSN->abyRSN[3] = WLAN_11i_CSS_TKIP;
4074 } else if (pMgmt->byCSSGK == KEY_CTL_CCMP) {
4075 sFrame.pRSN->abyRSN[3] = WLAN_11i_CSS_CCMP;
4076 } else {
4077 sFrame.pRSN->abyRSN[3] = WLAN_11i_CSS_UNKNOWN;
4078 }
4079
4080
4081 sFrame.pRSN->abyRSN[4] = 1;
4082 sFrame.pRSN->abyRSN[5] = 0;
4083 sFrame.pRSN->abyRSN[6] = 0x00;
4084 sFrame.pRSN->abyRSN[7] = 0x0F;
4085 sFrame.pRSN->abyRSN[8] = 0xAC;
4086 if (pMgmt->byCSSPK == KEY_CTL_TKIP) {
4087 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_TKIP;
4088 } else if (pMgmt->byCSSPK == KEY_CTL_CCMP) {
4089 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_CCMP;
4090 } else if (pMgmt->byCSSPK == KEY_CTL_NONE) {
4091 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_USE_GROUP;
4092 } else {
4093 sFrame.pRSN->abyRSN[9] = WLAN_11i_CSS_UNKNOWN;
4094 }
4095 sFrame.pRSN->len += 6;
4096
4097
4098 sFrame.pRSN->abyRSN[10] = 1;
4099 sFrame.pRSN->abyRSN[11] = 0;
4100 sFrame.pRSN->abyRSN[12] = 0x00;
4101 sFrame.pRSN->abyRSN[13] = 0x0F;
4102 sFrame.pRSN->abyRSN[14] = 0xAC;
4103 if (pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK) {
4104 sFrame.pRSN->abyRSN[15] = WLAN_11i_AKMSS_PSK;
4105 } else if (pMgmt->eAuthenMode == WMAC_AUTH_WPA2) {
4106 sFrame.pRSN->abyRSN[15] = WLAN_11i_AKMSS_802_1X;
4107 } else {
4108 sFrame.pRSN->abyRSN[15] = WLAN_11i_AKMSS_UNKNOWN;
4109 }
4110 sFrame.pRSN->len +=6;
4111
4112
4113 if (pMgmt->pCurrBSS->sRSNCapObj.bRSNCapExist == TRUE) {
4114 memcpy(&sFrame.pRSN->abyRSN[16], &pMgmt->pCurrBSS->sRSNCapObj.wRSNCap, 2);
4115 } else {
4116 sFrame.pRSN->abyRSN[16] = 0;
4117 sFrame.pRSN->abyRSN[17] = 0;
4118 }
4119 sFrame.pRSN->len +=2;
4120
4121 if ((pDevice->gsPMKID.BSSIDInfoCount > 0) && (pDevice->bRoaming == TRUE) && (pMgmt->eAuthenMode == WMAC_AUTH_WPA2)) {
4122
4123 pbyRSN = &sFrame.pRSN->abyRSN[18];
4124 pwPMKID = (PWORD)pbyRSN;
4125 *pwPMKID = 0;
4126 pbyRSN += 2;
4127 for (ii = 0; ii < pDevice->gsPMKID.BSSIDInfoCount; ii++) {
4128 if ( !memcmp(&pDevice->gsPMKID.BSSIDInfo[ii].BSSID[0], pMgmt->abyCurrBSSID, U_ETHER_ADDR_LEN)) {
4129 (*pwPMKID) ++;
4130 memcpy(pbyRSN, pDevice->gsPMKID.BSSIDInfo[ii].PMKID, 16);
4131 pbyRSN += 16;
4132 }
4133 }
4134 if (*pwPMKID != 0) {
4135 sFrame.pRSN->len += (2 + (*pwPMKID)*16);
4136 }
4137 }
4138
4139 sFrame.len += sFrame.pRSN->len + WLAN_IEHDR_LEN;
4140
4141 pMgmt->sAssocInfo.AssocInfo.RequestIELength += sFrame.pRSN->len + WLAN_IEHDR_LEN;
4142 memcpy(pbyIEs, sFrame.pRSN, sFrame.pRSN->len + WLAN_IEHDR_LEN);
4143 pbyIEs += sFrame.pRSN->len + WLAN_IEHDR_LEN;
4144 }
4145
4146
4147
4148 pTxPacket->cbMPDULen = sFrame.len;
4149 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
4150
4151 return pTxPacket;
4152}
4153
4154
4155
4156
4157
4158
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168PSTxMgmtPacket
4169s_MgrMakeAssocResponse(
4170 IN PSDevice pDevice,
4171 IN PSMgmtObject pMgmt,
4172 IN WORD wCurrCapInfo,
4173 IN WORD wAssocStatus,
4174 IN WORD wAssocAID,
4175 IN PBYTE pDstAddr,
4176 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
4177 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
4178 )
4179{
4180 PSTxMgmtPacket pTxPacket = NULL;
4181 WLAN_FR_ASSOCRESP sFrame;
4182
4183
4184 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
4185 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_ASSOCREQ_FR_MAXLEN);
4186 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
4187
4188 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
4189 sFrame.len = WLAN_REASSOCRESP_FR_MAXLEN;
4190 vMgrEncodeAssocResponse(&sFrame);
4191
4192 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
4193 (
4194 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
4195 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_ASSOCRESP)
4196 ));
4197 memcpy( sFrame.pHdr->sA3.abyAddr1, pDstAddr, WLAN_ADDR_LEN);
4198 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
4199 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
4200
4201 *sFrame.pwCapInfo = cpu_to_le16(wCurrCapInfo);
4202 *sFrame.pwStatus = cpu_to_le16(wAssocStatus);
4203 *sFrame.pwAid = cpu_to_le16((WORD)(wAssocAID | BIT14 | BIT15));
4204
4205
4206 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
4207 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN;
4208 memcpy(sFrame.pSuppRates,
4209 pCurrSuppRates,
4210 ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN
4211 );
4212
4213 if (((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len != 0) {
4214 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
4215 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
4216 memcpy(sFrame.pExtSuppRates,
4217 pCurrExtSuppRates,
4218 ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN
4219 );
4220 }
4221
4222
4223 pTxPacket->cbMPDULen = sFrame.len;
4224 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
4225
4226 return pTxPacket;
4227}
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242PSTxMgmtPacket
4243s_MgrMakeReAssocResponse(
4244 IN PSDevice pDevice,
4245 IN PSMgmtObject pMgmt,
4246 IN WORD wCurrCapInfo,
4247 IN WORD wAssocStatus,
4248 IN WORD wAssocAID,
4249 IN PBYTE pDstAddr,
4250 IN PWLAN_IE_SUPP_RATES pCurrSuppRates,
4251 IN PWLAN_IE_SUPP_RATES pCurrExtSuppRates
4252 )
4253{
4254 PSTxMgmtPacket pTxPacket = NULL;
4255 WLAN_FR_REASSOCRESP sFrame;
4256
4257
4258 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
4259 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_ASSOCREQ_FR_MAXLEN);
4260 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
4261
4262 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
4263 sFrame.len = WLAN_REASSOCRESP_FR_MAXLEN;
4264 vMgrEncodeReassocResponse(&sFrame);
4265
4266 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
4267 (
4268 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
4269 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_REASSOCRESP)
4270 ));
4271 memcpy( sFrame.pHdr->sA3.abyAddr1, pDstAddr, WLAN_ADDR_LEN);
4272 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
4273 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
4274
4275 *sFrame.pwCapInfo = cpu_to_le16(wCurrCapInfo);
4276 *sFrame.pwStatus = cpu_to_le16(wAssocStatus);
4277 *sFrame.pwAid = cpu_to_le16((WORD)(wAssocAID | BIT14 | BIT15));
4278
4279
4280 sFrame.pSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
4281 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN;
4282 memcpy(sFrame.pSuppRates,
4283 pCurrSuppRates,
4284 ((PWLAN_IE_SUPP_RATES)pCurrSuppRates)->len + WLAN_IEHDR_LEN
4285 );
4286
4287 if (((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len != 0) {
4288 sFrame.pExtSuppRates = (PWLAN_IE_SUPP_RATES)(sFrame.pBuf + sFrame.len);
4289 sFrame.len += ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
4290 memcpy(sFrame.pExtSuppRates,
4291 pCurrExtSuppRates,
4292 ((PWLAN_IE_SUPP_RATES)pCurrExtSuppRates)->len + WLAN_IEHDR_LEN
4293 );
4294 }
4295
4296
4297 pTxPacket->cbMPDULen = sFrame.len;
4298 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
4299
4300 return pTxPacket;
4301}
4302
4303
4304
4305
4306
4307
4308
4309
4310
4311
4312
4313
4314
4315static
4316VOID
4317s_vMgrRxProbeResponse(
4318 IN PSDevice pDevice,
4319 IN PSMgmtObject pMgmt,
4320 IN PSRxMgmtPacket pRxPacket
4321 )
4322{
4323 PKnownBSS pBSSList = NULL;
4324 WLAN_FR_PROBERESP sFrame;
4325 BYTE byCurrChannel = pRxPacket->byRxChannel;
4326 ERPObject sERP;
4327 BYTE byIEChannel = 0;
4328 BOOL bChannelHit = TRUE;
4329
4330
4331 memset(&sFrame, 0, sizeof(WLAN_FR_PROBERESP));
4332
4333 sFrame.len = pRxPacket->cbMPDULen;
4334 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
4335 vMgrDecodeProbeResponse(&sFrame);
4336
4337 if ((sFrame.pqwTimestamp == 0) ||
4338 (sFrame.pwBeaconInterval == 0) ||
4339 (sFrame.pwCapInfo == 0) ||
4340 (sFrame.pSSID == 0) ||
4341 (sFrame.pSuppRates == 0)) {
4342 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Probe resp:Fail addr:[%p] \n", pRxPacket->p80211Header);
4343 DBG_PORT80(0xCC);
4344 return;
4345 };
4346
4347 if(sFrame.pSSID->len == 0)
4348 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Rx Probe resp: SSID len = 0 \n");
4349
4350 if (sFrame.pDSParms != 0) {
4351 if (byCurrChannel > CB_MAX_CHANNEL_24G) {
4352
4353 byIEChannel = CARDbyGetChannelMapping(pMgmt->pAdapter, sFrame.pDSParms->byCurrChannel, PHY_TYPE_11A);
4354 } else {
4355 byIEChannel = sFrame.pDSParms->byCurrChannel;
4356 }
4357 if (byCurrChannel != byIEChannel) {
4358
4359 bChannelHit = FALSE;
4360 byCurrChannel = byIEChannel;
4361 }
4362 } else {
4363
4364 bChannelHit = TRUE;
4365 }
4366
4367
4368if(ChannelExceedZoneType(pDevice,byCurrChannel)==TRUE)
4369 return;
4370
4371 if (sFrame.pERP != NULL) {
4372 sERP.byERP = sFrame.pERP->byContext;
4373 sERP.bERPExist = TRUE;
4374 } else {
4375 sERP.bERPExist = FALSE;
4376 sERP.byERP = 0;
4377 }
4378
4379
4380
4381 pBSSList = BSSpAddrIsInBSSList((HANDLE)pDevice, sFrame.pHdr->sA3.abyAddr3, sFrame.pSSID);
4382 if (pBSSList) {
4383 BSSbUpdateToBSSList((HANDLE)pDevice,
4384 *sFrame.pqwTimestamp,
4385 *sFrame.pwBeaconInterval,
4386 *sFrame.pwCapInfo,
4387 byCurrChannel,
4388 bChannelHit,
4389 sFrame.pSSID,
4390 sFrame.pSuppRates,
4391 sFrame.pExtSuppRates,
4392 &sERP,
4393 sFrame.pRSN,
4394 sFrame.pRSNWPA,
4395 sFrame.pIE_Country,
4396 sFrame.pIE_Quiet,
4397 pBSSList,
4398 sFrame.len - WLAN_HDR_ADDR3_LEN,
4399 sFrame.pHdr->sA4.abyAddr4,
4400 (HANDLE)pRxPacket
4401 );
4402 }
4403 else {
4404 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Probe resp/insert: RxChannel = : %d\n", byCurrChannel);
4405 BSSbInsertToBSSList((HANDLE)pDevice,
4406 sFrame.pHdr->sA3.abyAddr3,
4407 *sFrame.pqwTimestamp,
4408 *sFrame.pwBeaconInterval,
4409 *sFrame.pwCapInfo,
4410 byCurrChannel,
4411 sFrame.pSSID,
4412 sFrame.pSuppRates,
4413 sFrame.pExtSuppRates,
4414 &sERP,
4415 sFrame.pRSN,
4416 sFrame.pRSNWPA,
4417 sFrame.pIE_Country,
4418 sFrame.pIE_Quiet,
4419 sFrame.len - WLAN_HDR_ADDR3_LEN,
4420 sFrame.pHdr->sA4.abyAddr4,
4421 (HANDLE)pRxPacket
4422 );
4423 }
4424 return;
4425
4426}
4427
4428
4429
4430
4431
4432
4433
4434
4435
4436
4437
4438
4439
4440static
4441VOID
4442s_vMgrRxProbeRequest(
4443 IN PSDevice pDevice,
4444 IN PSMgmtObject pMgmt,
4445 IN PSRxMgmtPacket pRxPacket
4446 )
4447{
4448 WLAN_FR_PROBEREQ sFrame;
4449 CMD_STATUS Status;
4450 PSTxMgmtPacket pTxPacket;
4451 BYTE byPHYType = BB_TYPE_11B;
4452
4453
4454
4455 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
4456 ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && pDevice->bBeaconSent)) {
4457
4458 memset(&sFrame, 0, sizeof(WLAN_FR_PROBEREQ));
4459
4460 sFrame.len = pRxPacket->cbMPDULen;
4461 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
4462 vMgrDecodeProbeRequest(&sFrame);
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472
4473 if (sFrame.pSSID->len != 0) {
4474 if (sFrame.pSSID->len != ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len)
4475 return;
4476 if (memcmp(sFrame.pSSID->abySSID,
4477 ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->abySSID,
4478 ((PWLAN_IE_SSID)pMgmt->abyCurrSSID)->len) != 0) {
4479 return;
4480 }
4481 }
4482
4483 if ((sFrame.pSuppRates->len > 4) || (sFrame.pExtSuppRates != NULL)) {
4484 byPHYType = BB_TYPE_11G;
4485 }
4486
4487
4488 pTxPacket = s_MgrMakeProbeResponse
4489 (
4490 pDevice,
4491 pMgmt,
4492 pMgmt->wCurrCapInfo,
4493 pMgmt->wCurrBeaconPeriod,
4494 pMgmt->uCurrChannel,
4495 0,
4496 sFrame.pHdr->sA3.abyAddr2,
4497 (PWLAN_IE_SSID)pMgmt->abyCurrSSID,
4498 (PBYTE)pMgmt->abyCurrBSSID,
4499 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
4500 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates,
4501 byPHYType
4502 );
4503 if (pTxPacket != NULL ){
4504
4505 Status = csMgmt_xmit(pDevice, pTxPacket);
4506 if (Status != CMD_STATUS_PENDING) {
4507 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Probe response tx failed\n");
4508 }
4509 else {
4510
4511 }
4512 }
4513 }
4514
4515 return;
4516}
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537VOID
4538vMgrRxManagePacket(
4539 IN HANDLE hDeviceContext,
4540 IN PSMgmtObject pMgmt,
4541 IN PSRxMgmtPacket pRxPacket
4542 )
4543{
4544 PSDevice pDevice = (PSDevice)hDeviceContext;
4545 BOOL bInScan = FALSE;
4546 UINT uNodeIndex = 0;
4547 NODE_STATE eNodeState = 0;
4548 CMD_STATUS Status;
4549
4550
4551 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
4552 if (BSSDBbIsSTAInNodeDB(pMgmt, pRxPacket->p80211Header->sA3.abyAddr2, &uNodeIndex))
4553 eNodeState = pMgmt->sNodeDBTable[uNodeIndex].eNodeState;
4554 }
4555
4556 switch( WLAN_GET_FC_FSTYPE((pRxPacket->p80211Header->sA3.wFrameCtl)) ){
4557
4558 case WLAN_FSTYPE_ASSOCREQ:
4559
4560 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx assocreq\n");
4561 if (eNodeState < NODE_AUTH) {
4562
4563
4564 vMgrDeAuthenBeginSta(pDevice,
4565 pMgmt,
4566 pRxPacket->p80211Header->sA3.abyAddr2,
4567 (6),
4568 &Status
4569 );
4570 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wmgr: send vMgrDeAuthenBeginSta 1\n");
4571 }
4572 else {
4573 s_vMgrRxAssocRequest(pDevice, pMgmt, pRxPacket, uNodeIndex);
4574 }
4575 break;
4576
4577 case WLAN_FSTYPE_ASSOCRESP:
4578
4579 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx assocresp1\n");
4580 s_vMgrRxAssocResponse(pDevice, pMgmt, pRxPacket, FALSE);
4581 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx assocresp2\n");
4582 break;
4583
4584 case WLAN_FSTYPE_REASSOCREQ:
4585
4586 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx reassocreq\n");
4587
4588 if (eNodeState < NODE_AUTH) {
4589
4590
4591 vMgrDeAuthenBeginSta(pDevice,
4592 pMgmt,
4593 pRxPacket->p80211Header->sA3.abyAddr2,
4594 (6),
4595 &Status
4596 );
4597 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wmgr: send vMgrDeAuthenBeginSta 2\n");
4598
4599 }
4600 s_vMgrRxReAssocRequest(pDevice, pMgmt, pRxPacket, uNodeIndex);
4601 break;
4602
4603 case WLAN_FSTYPE_REASSOCRESP:
4604
4605 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx reassocresp\n");
4606 s_vMgrRxAssocResponse(pDevice, pMgmt, pRxPacket, TRUE);
4607 break;
4608
4609 case WLAN_FSTYPE_PROBEREQ:
4610
4611
4612 s_vMgrRxProbeRequest(pDevice, pMgmt, pRxPacket);
4613 break;
4614
4615 case WLAN_FSTYPE_PROBERESP:
4616
4617 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx proberesp\n");
4618
4619 s_vMgrRxProbeResponse(pDevice, pMgmt, pRxPacket);
4620 break;
4621
4622 case WLAN_FSTYPE_BEACON:
4623
4624
4625 if (pMgmt->eScanState != WMAC_NO_SCANNING) {
4626 bInScan = TRUE;
4627 };
4628 s_vMgrRxBeacon(pDevice, pMgmt, pRxPacket, bInScan);
4629 break;
4630
4631 case WLAN_FSTYPE_ATIM:
4632
4633 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx atim\n");
4634 break;
4635
4636 case WLAN_FSTYPE_DISASSOC:
4637
4638 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx disassoc\n");
4639 if (eNodeState < NODE_AUTH) {
4640
4641
4642 vMgrDeAuthenBeginSta(pDevice,
4643 pMgmt,
4644 pRxPacket->p80211Header->sA3.abyAddr2,
4645 (6),
4646 &Status
4647 );
4648 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "wmgr: send vMgrDeAuthenBeginSta 3\n");
4649 }
4650 s_vMgrRxDisassociation(pDevice, pMgmt, pRxPacket);
4651 break;
4652
4653 case WLAN_FSTYPE_AUTHEN:
4654
4655 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx authen\n");
4656 s_vMgrRxAuthentication(pDevice, pMgmt, pRxPacket);
4657 break;
4658
4659 case WLAN_FSTYPE_DEAUTHEN:
4660
4661 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx deauthen\n");
4662 s_vMgrRxDeauthentication(pDevice, pMgmt, pRxPacket);
4663 break;
4664
4665 default:
4666 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx unknown mgmt\n");
4667 }
4668
4669 return;
4670}
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682
4683
4684
4685
4686BOOL
4687bMgrPrepareBeaconToSend(
4688 IN HANDLE hDeviceContext,
4689 IN PSMgmtObject pMgmt
4690 )
4691{
4692 PSDevice pDevice = (PSDevice)hDeviceContext;
4693 PSTxMgmtPacket pTxPacket;
4694
4695
4696 if (pDevice->bEncryptionEnable || pDevice->bEnable8021x){
4697 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_PRIVACY(1);
4698 }
4699 else {
4700 pMgmt->wCurrCapInfo &= ~WLAN_SET_CAP_INFO_PRIVACY(1);
4701 }
4702 pTxPacket = s_MgrMakeBeacon
4703 (
4704 pDevice,
4705 pMgmt,
4706 pMgmt->wCurrCapInfo,
4707 pMgmt->wCurrBeaconPeriod,
4708 pMgmt->uCurrChannel,
4709 pMgmt->wCurrATIMWindow,
4710 (PWLAN_IE_SSID)pMgmt->abyCurrSSID,
4711 (PBYTE)pMgmt->abyCurrBSSID,
4712 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
4713 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
4714 );
4715
4716 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) &&
4717 (pMgmt->abyCurrBSSID[0] == 0))
4718 return FALSE;
4719
4720 csBeacon_xmit(pDevice, pTxPacket);
4721
4722 return TRUE;
4723}
4724
4725
4726
4727
4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
4740static
4741VOID
4742s_vMgrLogStatus(
4743 IN PSMgmtObject pMgmt,
4744 IN WORD wStatus
4745 )
4746{
4747 switch( wStatus ){
4748 case WLAN_MGMT_STATUS_UNSPEC_FAILURE:
4749 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Unspecified error.\n");
4750 break;
4751 case WLAN_MGMT_STATUS_CAPS_UNSUPPORTED:
4752 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Can't support all requested capabilities.\n");
4753 break;
4754 case WLAN_MGMT_STATUS_REASSOC_NO_ASSOC:
4755 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Reassoc denied, can't confirm original Association.\n");
4756 break;
4757 case WLAN_MGMT_STATUS_ASSOC_DENIED_UNSPEC:
4758 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Assoc denied, undefine in spec\n");
4759 break;
4760 case WLAN_MGMT_STATUS_UNSUPPORTED_AUTHALG:
4761 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Peer doesn't support authen algorithm.\n");
4762 break;
4763 case WLAN_MGMT_STATUS_RX_AUTH_NOSEQ:
4764 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Authen frame received out of sequence.\n");
4765 break;
4766 case WLAN_MGMT_STATUS_CHALLENGE_FAIL:
4767 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Authen rejected, challenge failure.\n");
4768 break;
4769 case WLAN_MGMT_STATUS_AUTH_TIMEOUT:
4770 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Authen rejected, timeout waiting for next frame.\n");
4771 break;
4772 case WLAN_MGMT_STATUS_ASSOC_DENIED_BUSY:
4773 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Assoc denied, AP too busy.\n");
4774 break;
4775 case WLAN_MGMT_STATUS_ASSOC_DENIED_RATES:
4776 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Assoc denied, we haven't enough basic rates.\n");
4777 break;
4778 case WLAN_MGMT_STATUS_ASSOC_DENIED_SHORTPREAMBLE:
4779 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Assoc denied, we do not support short preamble.\n");
4780 break;
4781 case WLAN_MGMT_STATUS_ASSOC_DENIED_PBCC:
4782 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Assoc denied, we do not support PBCC.\n");
4783 break;
4784 case WLAN_MGMT_STATUS_ASSOC_DENIED_AGILITY:
4785 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Status code == Assoc denied, we do not support channel agility.\n");
4786 break;
4787 default:
4788 DBG_PRT(MSG_LEVEL_NOTICE, KERN_INFO "Unknown status code %d.\n", wStatus);
4789 break;
4790 }
4791}
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
4805
4806
4807
4808
4809
4810BOOL
4811bAdd_PMKID_Candidate (
4812 IN HANDLE hDeviceContext,
4813 IN PBYTE pbyBSSID,
4814 IN PSRSNCapObject psRSNCapObj
4815 )
4816{
4817 PSDevice pDevice = (PSDevice)hDeviceContext;
4818 PPMKID_CANDIDATE pCandidateList;
4819 UINT ii = 0;
4820
4821 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"bAdd_PMKID_Candidate START: (%d)\n", (int)pDevice->gsPMKIDCandidate.NumCandidates);
4822
4823 if ((pDevice == NULL) || (pbyBSSID == NULL) || (psRSNCapObj == NULL))
4824 return FALSE;
4825
4826 if (pDevice->gsPMKIDCandidate.NumCandidates >= MAX_PMKIDLIST)
4827 return FALSE;
4828
4829
4830
4831
4832 for (ii = 0; ii < pDevice->gsPMKIDCandidate.NumCandidates; ii++) {
4833 pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[ii];
4834 if ( !memcmp(pCandidateList->BSSID, pbyBSSID, U_ETHER_ADDR_LEN)) {
4835 if ((psRSNCapObj->bRSNCapExist == TRUE) && (psRSNCapObj->wRSNCap & BIT0)) {
4836 pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED;
4837 } else {
4838 pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED);
4839 }
4840 return TRUE;
4841 }
4842 }
4843
4844
4845 pCandidateList = &pDevice->gsPMKIDCandidate.CandidateList[pDevice->gsPMKIDCandidate.NumCandidates];
4846 if ((psRSNCapObj->bRSNCapExist == TRUE) && (psRSNCapObj->wRSNCap & BIT0)) {
4847 pCandidateList->Flags |= NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED;
4848 } else {
4849 pCandidateList->Flags &= ~(NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED);
4850 }
4851 memcpy(pCandidateList->BSSID, pbyBSSID, U_ETHER_ADDR_LEN);
4852 pDevice->gsPMKIDCandidate.NumCandidates++;
4853 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"NumCandidates:%d\n", (int)pDevice->gsPMKIDCandidate.NumCandidates);
4854 return TRUE;
4855}
4856
4857
4858
4859
4860
4861
4862
4863
4864
4865
4866
4867
4868
4869
4870
4871VOID
4872vFlush_PMKID_Candidate (
4873 IN HANDLE hDeviceContext
4874 )
4875{
4876 PSDevice pDevice = (PSDevice)hDeviceContext;
4877
4878 if (pDevice == NULL)
4879 return;
4880
4881 memset(&pDevice->gsPMKIDCandidate, 0, sizeof(SPMKIDCandidateEvent));
4882}
4883
4884static BOOL
4885s_bCipherMatch (
4886 IN PKnownBSS pBSSNode,
4887 IN NDIS_802_11_ENCRYPTION_STATUS EncStatus,
4888 OUT PBYTE pbyCCSPK,
4889 OUT PBYTE pbyCCSGK
4890 )
4891{
4892 BYTE byMulticastCipher = KEY_CTL_INVALID;
4893 BYTE byCipherMask = 0x00;
4894 int i;
4895
4896 if (pBSSNode == NULL)
4897 return FALSE;
4898
4899
4900 if ((WLAN_GET_CAP_INFO_PRIVACY(pBSSNode->wCapInfo) != 0) &&
4901 (EncStatus == Ndis802_11Encryption1Enabled)) {
4902
4903 byMulticastCipher = KEY_CTL_WEP;
4904 }
4905
4906 if ((WLAN_GET_CAP_INFO_PRIVACY(pBSSNode->wCapInfo) != 0) &&
4907 (pBSSNode->bWPA2Valid == TRUE) &&
4908
4909 ((EncStatus == Ndis802_11Encryption3Enabled)||(EncStatus == Ndis802_11Encryption2Enabled))) {
4910
4911
4912 if ((pBSSNode->byCSSGK == WLAN_11i_CSS_WEP40) ||
4913 (pBSSNode->byCSSGK == WLAN_11i_CSS_WEP104)) {
4914 byMulticastCipher = KEY_CTL_WEP;
4915 } else if (pBSSNode->byCSSGK == WLAN_11i_CSS_TKIP) {
4916 byMulticastCipher = KEY_CTL_TKIP;
4917 } else if (pBSSNode->byCSSGK == WLAN_11i_CSS_CCMP) {
4918 byMulticastCipher = KEY_CTL_CCMP;
4919 } else {
4920 byMulticastCipher = KEY_CTL_INVALID;
4921 }
4922
4923
4924 for(i=0;i<pBSSNode->wCSSPKCount;i++) {
4925 if ((pBSSNode->abyCSSPK[i] == WLAN_11i_CSS_WEP40) ||
4926 (pBSSNode->abyCSSPK[i] == WLAN_11i_CSS_WEP104)) {
4927
4928 byCipherMask |= 0x01;
4929 } else if (pBSSNode->abyCSSPK[i] == WLAN_11i_CSS_TKIP) {
4930 byCipherMask |= 0x02;
4931 } else if (pBSSNode->abyCSSPK[i] == WLAN_11i_CSS_CCMP) {
4932 byCipherMask |= 0x04;
4933 } else if (pBSSNode->abyCSSPK[i] == WLAN_11i_CSS_USE_GROUP) {
4934
4935 byCipherMask = 0;
4936 i = pBSSNode->wCSSPKCount;
4937 }
4938 }
4939
4940 } else if ((WLAN_GET_CAP_INFO_PRIVACY(pBSSNode->wCapInfo) != 0) &&
4941 (pBSSNode->bWPAValid == TRUE) &&
4942 ((EncStatus == Ndis802_11Encryption3Enabled) || (EncStatus == Ndis802_11Encryption2Enabled))) {
4943
4944
4945 if ((pBSSNode->byGKType == WPA_WEP40) ||
4946 (pBSSNode->byGKType == WPA_WEP104)) {
4947 byMulticastCipher = KEY_CTL_WEP;
4948 } else if (pBSSNode->byGKType == WPA_TKIP) {
4949 byMulticastCipher = KEY_CTL_TKIP;
4950 } else if (pBSSNode->byGKType == WPA_AESCCMP) {
4951 byMulticastCipher = KEY_CTL_CCMP;
4952 } else {
4953 byMulticastCipher = KEY_CTL_INVALID;
4954 }
4955
4956
4957 for(i=0;i<pBSSNode->wPKCount;i++) {
4958 if (pBSSNode->abyPKType[i] == WPA_TKIP) {
4959 byCipherMask |= 0x02;
4960 } else if (pBSSNode->abyPKType[i] == WPA_AESCCMP) {
4961 byCipherMask |= 0x04;
4962 } else if (pBSSNode->abyPKType[i] == WPA_NONE) {
4963
4964 byCipherMask = 0;
4965 i = pBSSNode->wPKCount;
4966 }
4967 }
4968 }
4969
4970 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%d, %d, %d, %d, EncStatus:%d\n",
4971 byMulticastCipher, byCipherMask, pBSSNode->bWPAValid, pBSSNode->bWPA2Valid, EncStatus);
4972
4973
4974 if (EncStatus == Ndis802_11Encryption1Enabled) {
4975
4976
4977 if ((byMulticastCipher == KEY_CTL_WEP) &&
4978 (byCipherMask == 0)) {
4979 *pbyCCSGK = KEY_CTL_WEP;
4980 *pbyCCSPK = KEY_CTL_NONE;
4981 return TRUE;
4982 } else {
4983 return FALSE;
4984 }
4985
4986 } else if (EncStatus == Ndis802_11Encryption2Enabled) {
4987 if ((byMulticastCipher == KEY_CTL_TKIP) &&
4988 (byCipherMask == 0)) {
4989 *pbyCCSGK = KEY_CTL_TKIP;
4990 *pbyCCSPK = KEY_CTL_NONE;
4991 return TRUE;
4992 } else if ((byMulticastCipher == KEY_CTL_WEP) &&
4993 ((byCipherMask & 0x02) != 0)) {
4994 *pbyCCSGK = KEY_CTL_WEP;
4995 *pbyCCSPK = KEY_CTL_TKIP;
4996 return TRUE;
4997 } else if ((byMulticastCipher == KEY_CTL_TKIP) &&
4998 ((byCipherMask & 0x02) != 0)) {
4999 *pbyCCSGK = KEY_CTL_TKIP;
5000 *pbyCCSPK = KEY_CTL_TKIP;
5001 return TRUE;
5002 } else {
5003 return FALSE;
5004 }
5005 } else if (EncStatus == Ndis802_11Encryption3Enabled) {
5006 if ((byMulticastCipher == KEY_CTL_CCMP) &&
5007 (byCipherMask == 0)) {
5008
5009 return FALSE;
5010 } else if ((byMulticastCipher == KEY_CTL_WEP) &&
5011 ((byCipherMask & 0x04) != 0)) {
5012 *pbyCCSGK = KEY_CTL_WEP;
5013 *pbyCCSPK = KEY_CTL_CCMP;
5014 return TRUE;
5015 } else if ((byMulticastCipher == KEY_CTL_TKIP) &&
5016 ((byCipherMask & 0x04) != 0)) {
5017 *pbyCCSGK = KEY_CTL_TKIP;
5018 *pbyCCSPK = KEY_CTL_CCMP;
5019 return TRUE;
5020 } else if ((byMulticastCipher == KEY_CTL_CCMP) &&
5021 ((byCipherMask & 0x04) != 0)) {
5022 *pbyCCSGK = KEY_CTL_CCMP;
5023 *pbyCCSPK = KEY_CTL_CCMP;
5024 return TRUE;
5025 } else {
5026 return FALSE;
5027 }
5028 }
5029 return TRUE;
5030}
5031
5032
5033