?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: thinkpad-acpi: add development version tag
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / vt6655 / wmgr.c
blob659be05a33effd6c70650b65b1088f05024cbd9d
1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 *
20 * File: wmgr.c
21 *
22 * Purpose: Handles the 802.11 management functions
23 *
24 * Author: Lyndon Chen
25 *
26 * Date: May 8, 2002
27 *
28 * Functions:
29 * nsMgrObjectInitial - Initialize Management Objet data structure
30 * vMgrObjectReset - Reset Management Objet data structure
31 * vMgrAssocBeginSta - Start associate function
32 * vMgrReAssocBeginSta - Start reassociate function
33 * vMgrDisassocBeginSta - Start disassociate function
34 * s_vMgrRxAssocRequest - Handle Rcv associate_request
35 * s_vMgrRxAssocResponse - Handle Rcv associate_response
36 * vMrgAuthenBeginSta - Start authentication function
37 * vMgrDeAuthenDeginSta - Start deauthentication function
38 * s_vMgrRxAuthentication - Handle Rcv authentication
39 * s_vMgrRxAuthenSequence_1 - Handle Rcv authentication sequence 1
40 * s_vMgrRxAuthenSequence_2 - Handle Rcv authentication sequence 2
41 * s_vMgrRxAuthenSequence_3 - Handle Rcv authentication sequence 3
42 * s_vMgrRxAuthenSequence_4 - Handle Rcv authentication sequence 4
43 * s_vMgrRxDisassociation - Handle Rcv disassociation
44 * s_vMgrRxBeacon - Handle Rcv Beacon
45 * vMgrCreateOwnIBSS - Create ad_hoc IBSS or AP BSS
46 * vMgrJoinBSSBegin - Join BSS function
47 * s_vMgrSynchBSS - Synch & adopt BSS parameters
48 * s_MgrMakeBeacon - Create Baecon frame
49 * s_MgrMakeProbeResponse - Create Probe Response frame
50 * s_MgrMakeAssocRequest - Create Associate Request frame
51 * s_MgrMakeReAssocRequest - Create ReAssociate Request frame
52 * s_vMgrRxProbeResponse - Handle Rcv probe_response
53 * s_vMrgRxProbeRequest - Handle Rcv probe_request
54 * bMgrPrepareBeaconToSend - Prepare Beacon frame
55 * s_vMgrLogStatus - Log 802.11 Status
56 * vMgrRxManagePacket - Rcv management frame dispatch function
57 * s_vMgrFormatTIM- Assember TIM field of beacon
58 * vMgrTimerInit- Initial 1-sec and command call back funtions
59 *
60 * Revision History:
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 /*--------------------- Static Definitions -------------------------*/
85
86
87
88 /*--------------------- Static Classes ----------------------------*/
89
90 /*--------------------- Static Variables --------------------------*/
91 static int msglevel =MSG_LEVEL_INFO;
92 //static int msglevel =MSG_LEVEL_DEBUG;
93
94 /*--------------------- Static Functions --------------------------*/
95 //2008-8-4 <add> by chester
96 static BOOL ChannelExceedZoneType(
97 IN PSDevice pDevice,
98 IN BYTE byCurrChannel
99 );
100
101 // Association/diassociation functions
102 static
103 PSTxMgmtPacket
104 s_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
115 static
116 VOID
117 s_vMgrRxAssocRequest(
118 IN PSDevice pDevice,
119 IN PSMgmtObject pMgmt,
120 IN PSRxMgmtPacket pRxPacket,
121 IN UINT uNodeIndex
122 );
123
124 static
125 PSTxMgmtPacket
126 s_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
137 static
138 VOID
139 s_vMgrRxAssocResponse(
140 IN PSDevice pDevice,
141 IN PSMgmtObject pMgmt,
142 IN PSRxMgmtPacket pRxPacket,
143 IN BOOL bReAssocType
144 );
145
146 static
147 VOID
148 s_vMgrRxDisassociation(
149 IN PSDevice pDevice,
150 IN PSMgmtObject pMgmt,
151 IN PSRxMgmtPacket pRxPacket
152 );
153
154 // Authentication/deauthen functions
155 static
156 VOID
157 s_vMgrRxAuthenSequence_1(
158 IN PSDevice pDevice,
159 IN PSMgmtObject pMgmt,
160 IN PWLAN_FR_AUTHEN pFrame
161 );
162
163 static
164 VOID
165 s_vMgrRxAuthenSequence_2(
166 IN PSDevice pDevice,
167 IN PSMgmtObject pMgmt,
168 IN PWLAN_FR_AUTHEN pFrame
169 );
170
171 static
172 VOID
173 s_vMgrRxAuthenSequence_3(
174 IN PSDevice pDevice,
175 IN PSMgmtObject pMgmt,
176 IN PWLAN_FR_AUTHEN pFrame
177 );
178
179 static
180 VOID
181 s_vMgrRxAuthenSequence_4(
182 IN PSDevice pDevice,
183 IN PSMgmtObject pMgmt,
184 IN PWLAN_FR_AUTHEN pFrame
185 );
186
187 static
188 VOID
189 s_vMgrRxAuthentication(
190 IN PSDevice pDevice,
191 IN PSMgmtObject pMgmt,
192 IN PSRxMgmtPacket pRxPacket
193 );
194
195 static
196 VOID
197 s_vMgrRxDeauthentication(
198 IN PSDevice pDevice,
199 IN PSMgmtObject pMgmt,
200 IN PSRxMgmtPacket pRxPacket
201 );
202
203 // Scan functions
204 // probe request/response functions
205 static
206 VOID
207 s_vMgrRxProbeRequest(
208 IN PSDevice pDevice,
209 IN PSMgmtObject pMgmt,
210 IN PSRxMgmtPacket pRxPacket
211 );
212
213 static
214 VOID
215 s_vMgrRxProbeResponse(
216 IN PSDevice pDevice,
217 IN PSMgmtObject pMgmt,
218 IN PSRxMgmtPacket pRxPacket
219 );
220
221 // beacon functions
222 static
223 VOID
224 s_vMgrRxBeacon(
225 IN PSDevice pDevice,
226 IN PSMgmtObject pMgmt,
227 IN PSRxMgmtPacket pRxPacket,
228 IN BOOL bInScan
229 );
230
231 static
232 VOID
233 s_vMgrFormatTIM(
234 IN PSMgmtObject pMgmt,
235 IN PWLAN_IE_TIM pTIM
236 );
237
238 static
239 PSTxMgmtPacket
240 s_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 // Association response
255 static
256 PSTxMgmtPacket
257 s_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 // ReAssociation response
269 static
270 PSTxMgmtPacket
271 s_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 // Probe response
283 static
284 PSTxMgmtPacket
285 s_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 // received status
301 static
302 VOID
303 s_vMgrLogStatus(
304 IN PSMgmtObject pMgmt,
305 IN WORD wStatus
306 );
307
308
309 static
310 VOID
311 s_vMgrSynchBSS (
312 IN PSDevice pDevice,
313 IN UINT uBSSMode,
314 IN PKnownBSS pCurr,
315 OUT PCMD_STATUS pStatus
316 );
317
318
319 static BOOL
320 s_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 /*--------------------- Export Variables --------------------------*/
335
336
337 /*--------------------- Export Functions --------------------------*/
338
339
340 /*+
341 *
342 * Routine Description:
343 * Allocates and initializes the Management object.
344 *
345 * Return Value:
346 * Ndis_staus.
347 *
348 -*/
349
350 VOID
351 vMgrObjectInit(
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 //memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN +1);
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 * Routine Description:
379 * Initializes timer object
380 *
381 * Return Value:
382 * Ndis_staus.
383 *
384 -*/
385
386 void
387 vMgrTimerInit(
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); //10s callback
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 * Routine Description:
427 * Reset the management object structure.
428 *
429 * Return Value:
430 * None.
431 *
432 -*/
433
434 VOID
435 vMgrObjectReset(
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 // TODO: timer
446
447 return;
448 }
449
450
451 /*+
452 *
453 * Routine Description:
454 * Start the station association procedure. Namely, send an
455 * association request frame to the AP.
456 *
457 * Return Value:
458 * None.
459 *
460 -*/
461
462
463 VOID
464 vMgrAssocBeginSta(
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 // always allow receive short preamble
480 //if (pDevice->byPreambleType == 1) {
481 // pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
482 //}
483 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
484 if (pMgmt->wListenInterval == 0)
485 pMgmt->wListenInterval = 1; // at least one.
486
487 // ERP Phy (802.11g) should support short preamble.
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 /* build an assocreq frame and send it */
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 /* send the frame */
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 * Routine Description:
532 * Start the station re-association procedure.
533 *
534 * Return Value:
535 * None.
536 *
537 -*/
538
539 VOID
540 vMgrReAssocBeginSta(
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 //if (pDevice->byPreambleType == 1) {
558 // pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
559 //}
560 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
561
562 if (pMgmt->wListenInterval == 0)
563 pMgmt->wListenInterval = 1; // at least one.
564
565
566 // ERP Phy (802.11g) should support short preamble.
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 /* send the frame */
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 * Routine Description:
611 * Send an dis-association request frame to the AP.
612 *
613 * Return Value:
614 * None.
615 *
616 -*/
617
618 VOID
619 vMgrDisassocBeginSta(
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 // Setup the sFrame structure
636 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
637 sFrame.len = WLAN_DISASSOC_FR_MAXLEN;
638
639 // format fixed field frame structure
640 vMgrEncodeDisassociation(&sFrame);
641
642 // Setup the header
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 // Set reason code
654 *(sFrame.pwReason) = cpu_to_le16(wReason);
655 pTxPacket->cbMPDULen = sFrame.len;
656 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
657
658 // send the frame
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 * Routine Description:(AP function)
673 * Handle incoming station association request frames.
674 *
675 * Return Value:
676 * None.
677 *
678 -*/
679
680 static
681 VOID
682 s_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 // node index not found
702 if (!uNodeIndex)
703 return;
704
705 //check if node is authenticated
706 //decode the frame
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 // Todo: check sta basic rate, if ap can't support, set status code
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, // do not change our basic rate
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 // set max tx rate
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 // Todo: check sta preamble, if ap can't support, set status code
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 // check if ERP support
765 if(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate > RATE_11M)
766 pMgmt->sNodeDBTable[uNodeIndex].bERPExist = TRUE;
767
768 if (pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate <= RATE_11M) {
769 // B only STA join
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 }//else { TODO: received STA under state1 handle }
789 else {
790 return;
791 }
792
793
794 // assoc response reply..
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 /* send the frame */
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 * Description:(AP function)
829 * Handle incoming station re-association request frames.
830 *
831 * Parameters:
832 * In:
833 * pMgmt - Management Object structure
834 * pRxPacket - Received Packet
835 * Out:
836 * none
837 *
838 * Return Value: None.
839 *
840 -*/
841
842 static
843 VOID
844 s_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 // node index not found
863 if (!uNodeIndex)
864 return;
865 //check if node is authenticated
866 //decode the frame
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 // Todo: check sta basic rate, if ap can't support, set status code
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, // do not change our basic rate
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 // set max tx rate
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 // Todo: check sta preamble, if ap can't support, set status code
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 // if suppurt ERP
925 if(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate > RATE_11M)
926 pMgmt->sNodeDBTable[uNodeIndex].bERPExist = TRUE;
927
928 if (pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate <= RATE_11M) {
929 // B only STA join
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 // assoc response reply..
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 /* send the frame */
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 * Routine Description:
985 * Handle incoming association response frames.
986 *
987 * Return Value:
988 * None.
989 *
990 -*/
991
992 static
993 VOID
994 s_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 // decode the frame
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 // save values and set current BSS state
1035 if (cpu_to_le16((*(sFrame.pwStatus))) == WLAN_MGMT_STATUS_SUCCESS ){
1036 // set AID
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)) { //data room not enough
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 //2008-0409-07, <Add> by Einsn Liu
1075 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1076 //if(pDevice->bWPADevEnable == TRUE)
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 //#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1112 //End Add -- //2008-0409-07, <Add> by Einsn Liu
1113 }
1114 else {
1115 if (bReAssocType) {
1116 pMgmt->eCurrState = WMAC_STATE_IDLE;
1117 }
1118 else {
1119 // jump back to the auth state and indicate the error
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 //need clear flags related to Networkmanager
1129
1130 pDevice->bwextcount = 0;
1131 pDevice->bWPASuppWextEnabled = FALSE;
1132 #endif
1133
1134
1135 if(pMgmt->eCurrState == WMAC_STATE_ASSOC)
1136 timer_expire(pDevice->sTimerCommand, 0);
1137 return;
1138 }
1139
1140
1141
1142 /*+
1143 *
1144 * Routine Description:
1145 * Start the station authentication procedure. Namely, send an
1146 * authentication frame to the AP.
1147 *
1148 * Return Value:
1149 * None.
1150 *
1151 -*/
1152
1153 VOID
1154 vMgrAuthenBeginSta(
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 /* insert values */
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 /* Adjust the length fields */
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 * Routine Description:
1203 * Start the station(AP) deauthentication procedure. Namely, send an
1204 * deauthentication frame to the AP or Sta.
1205 *
1206 * Return Value:
1207 * None.
1208 *
1209 -*/
1210
1211 VOID
1212 vMgrDeAuthenBeginSta(
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 /* insert values */
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); // deauthen. bcs left BSS
1243 /* Adjust the length fields */
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 * Routine Description:
1260 * Handle incoming authentication frames.
1261 *
1262 * Return Value:
1263 * None.
1264 *
1265 -*/
1266
1267 static
1268 VOID
1269 s_vMgrRxAuthentication(
1270 IN PSDevice pDevice,
1271 IN PSMgmtObject pMgmt,
1272 IN PSRxMgmtPacket pRxPacket
1273 )
1274 {
1275 WLAN_FR_AUTHEN sFrame;
1276
1277 // we better be an AP or a STA in AUTHPENDING otherwise ignore
1278 if (!(pMgmt->eCurrMode == WMAC_MODE_ESS_AP ||
1279 pMgmt->eCurrState == WMAC_STATE_AUTHPENDING)) {
1280 return;
1281 }
1282
1283 // decode the frame
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 //AP funciton
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 //AP funciton
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 * Routine Description:
1315 * Handles incoming authen frames with sequence 1. Currently
1316 * assumes we're an AP. So far, no one appears to use authentication
1317 * in Ad-Hoc mode.
1318 *
1319 * Return Value:
1320 * None.
1321 *
1322 -*/
1323
1324
1325 static
1326 VOID
1327 s_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 // Insert a Node entry
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 // send auth reply
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 // format buffer structure
1360 vMgrEncodeAuthen(&sFrame);
1361 // insert values
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 // get group key
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 /* Adjust the length fields */
1404 pTxPacket->cbMPDULen = sFrame.len;
1405 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1406 // send the frame
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 * Routine Description:
1422 * Handles incoming auth frames with sequence number 2. Currently
1423 * assumes we're a station.
1424 *
1425 *
1426 * Return Value:
1427 * None.
1428 *
1429 -*/
1430
1431 static
1432 VOID
1433 s_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 // spin_unlock_irq(&pDevice->lock);
1458 // vCommandTimerWait((HANDLE)pDevice, 0);
1459 // spin_lock_irq(&pDevice->lock);
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 // format buffer structure
1473 vMgrEncodeAuthen(&sFrame);
1474 // insert values
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 // Adjust the length fields
1493 pTxPacket->cbMPDULen = sFrame.len;
1494 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1495 // send the frame
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 // spin_unlock_irq(&pDevice->lock);
1505 // vCommandTimerWait((HANDLE)pDevice, 0);
1506 // spin_lock_irq(&pDevice->lock);
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 * Routine Description:
1523 * Handles incoming authen frames with sequence 3. Currently
1524 * assumes we're an AP. This function assumes the frame has
1525 * already been successfully decrypted.
1526 *
1527 *
1528 * Return Value:
1529 * None.
1530 *
1531 -*/
1532
1533 static
1534 VOID
1535 s_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
1572 reply:
1573 // send auth reply
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 // format buffer structure
1580 vMgrEncodeAuthen(&sFrame);
1581 /* insert values */
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 /* Adjust the length fields */
1596 pTxPacket->cbMPDULen = sFrame.len;
1597 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1598 // send the frame
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 * Routine Description:
1614 * Handles incoming authen frames with sequence 4
1615 *
1616 *
1617 * Return Value:
1618 * None.
1619 *
1620 -*/
1621 static
1622 VOID
1623 s_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 // spin_unlock_irq(&pDevice->lock);
1643 // vCommandTimerWait((HANDLE)pDevice, 0);
1644 // spin_lock_irq(&pDevice->lock);
1645 }
1646
1647 }
1648
1649 /*+
1650 *
1651 * Routine Description:
1652 * Handles incoming disassociation frames
1653 *
1654 *
1655 * Return Value:
1656 * None.
1657 *
1658 -*/
1659
1660 static
1661 VOID
1662 s_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 // CMD_STATUS CmdStatus;
1671 viawget_wpa_header *wpahdr;
1672
1673 if ( pMgmt->eCurrMode == WMAC_MODE_ESS_AP ){
1674 // if is acting an AP..
1675 // a STA is leaving this BSS..
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 //TODO: do something let upper layer know or
1691 //try to send associate packet again because of inactivity timeout
1692 // if (pMgmt->eCurrState == WMAC_STATE_ASSOC) {
1693 // vMgrReAssocBeginSta((PSDevice)pDevice, pMgmt, &CmdStatus);
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 // if(pDevice->bWPASuppWextEnabled == TRUE)
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 /* else, ignore it */
1723
1724 return;
1725 }
1726
1727
1728 /*+
1729 *
1730 * Routine Description:
1731 * Handles incoming deauthentication frames
1732 *
1733 *
1734 * Return Value:
1735 * None.
1736 *
1737 -*/
1738
1739 static
1740 VOID
1741 s_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 //Todo:
1754 // if is acting an AP..
1755 // a STA is leaving this BSS..
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 // TODO: update BSS list for specific BSSID if pre-authentication case
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 // if(pDevice->bWPASuppWextEnabled == TRUE)
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 /* else, ignore it. TODO: IBSS authentication service
1810 would be implemented here */
1811 };
1812 return;
1813 }
1814
1815
1816 //2008-8-4 <add> by chester
1817 /*+
1818 *
1819 * Routine Description:
1820 * check if current channel is match ZoneType.
1821 *for USA:1~11;
1822 * Japan:1~13;
1823 * Europe:1~13
1824 * Return Value:
1825 * True:exceed;
1826 * False:normal case
1827 -*/
1828 static BOOL
1829 ChannelExceedZoneType(
1830 IN PSDevice pDevice,
1831 IN BYTE byCurrChannel
1832 )
1833 {
1834 BOOL exceed=FALSE;
1835
1836 switch(pDevice->byZoneType) {
1837 case 0x00: //USA:1~11
1838 if((byCurrChannel<1) ||(byCurrChannel>11))
1839 exceed = TRUE;
1840 break;
1841 case 0x01: //Japan:1~13
1842 case 0x02: //Europe:1~13
1843 if((byCurrChannel<1) ||(byCurrChannel>13))
1844 exceed = TRUE;
1845 break;
1846 default: //reserve for other zonetype
1847 break;
1848 }
1849
1850 return exceed;
1851 }
1852
1853
1854 /*+
1855 *
1856 * Routine Description:
1857 * Handles and analysis incoming beacon frames.
1858 *
1859 *
1860 * Return Value:
1861 * None.
1862 *
1863 -*/
1864
1865 static
1866 VOID
1867 s_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 // decode the beacon frame
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 // channel remapping to
1920 byIEChannel = CARDbyGetChannelMapping(pDevice, sFrame.pDSParms->byCurrChannel, PHY_TYPE_11A);
1921 } else {
1922 byIEChannel = sFrame.pDSParms->byCurrChannel;
1923 }
1924 if (byCurrChannel != byIEChannel) {
1925 // adjust channel info. bcs we rcv adjcent channel pakckets
1926 bChannelHit = FALSE;
1927 byCurrChannel = byIEChannel;
1928 }
1929 } else {
1930 // no DS channel info
1931 bChannelHit = TRUE;
1932 }
1933 //2008-0730-01<Add>by MikeLiu
1934 if(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, // payload of beacon
1965 (HANDLE)pRxPacket
1966 );
1967 }
1968 else {
1969 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"update bcn: RxChannel = : %d\n", byCurrChannel);
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, // payload of probresponse
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 // if rx beacon without ERP field
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 // set to MAC&BBP
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 // check if BSSID the same
2034 if (memcmp(sFrame.pHdr->sA3.abyAddr3,
2035 pMgmt->abyCurrBSSID,
2036 WLAN_BSSID_LEN) == 0) {
2037
2038 bIsBSSIDEqual = TRUE;
2039
2040 // 2008-05-21 <add> by Richardtai
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 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BCN:Wake Count= [%d]\n", pMgmt->wCountToWakeUp);
2047 }
2048 }
2049 // check if SSID the same
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 // add state check to prevent reconnect fail since we'll receive Beacon
2065
2066 bIsAPBeacon = TRUE;
2067
2068 if (pBSSList != NULL) {
2069
2070 // Compare PHY paramater setting
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 // Basic Rate Set may change dynamiclly
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 //printk("RxBeacon:MaxSuppRate is %d\n",pMgmt->sNodeDBTable[0].wMaxSuppRate);
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 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Beacon 2 \n");
2136 // check if CF field exisit
2137 if (WLAN_GET_CAP_INFO_ESS(*sFrame.pwCapInfo)) {
2138 if (sFrame.pCFParms->wCFPDurRemaining > 0) {
2139 // TODO: deal with CFP period to set NAV
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 // check if beacon TSF larger or small than our local TSF
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 // if infra mode
2178 if (bIsAPBeacon == TRUE) {
2179
2180 // Infra mode: Local TSF always follow AP's TSF if Difference huge.
2181 if (bTSFLargeDiff)
2182 bUpdateTSF = TRUE;
2183
2184 if ((pDevice->bEnablePSMode == TRUE) &&(sFrame.pTIM != 0)) {
2185
2186 // deal with DTIM, analysis TIM
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 // check if AID in TIM field bit on
2193 // wStartIndex = N1
2194 wStartIndex = WLAN_MGMT_GET_TIM_OFFSET(sFrame.pTIM->byBitMapCtl) << 1;
2195 // AIDIndex = N2
2196 wAIDIndex = (wAIDNumber >> 3);
2197 if ((wAIDNumber > 0) && (wAIDIndex >= wStartIndex)) {
2198 uLocateByteIndex = wAIDIndex - wStartIndex;
2199 // len = byDTIMCount + byDTIMPeriod + byDTIMPeriod + byVirtBitMap[0~250]
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 // send out ps-poll packet
2216 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "BCN:In TIM\n");
2217 if (pMgmt->bInTIM) {
2218 PSvSendPSPOLL((PSDevice)pDevice);
2219 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "BCN:PS-POLL sent..\n");
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 // if adhoc mode
2240 if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && !bIsAPBeacon && bIsChannelEqual) {
2241 if (bIsBSSIDEqual) {
2242 // Use sNodeDBTable[0].uInActiveCount as IBSS beacons received count.
2243 if (pMgmt->sNodeDBTable[0].uInActiveCount != 0)
2244 pMgmt->sNodeDBTable[0].uInActiveCount = 0;
2245
2246 // adhoc mode:TSF updated only when beacon larger then local TSF
2247 if (bTSFLargeDiff && bTSFOffsetPostive &&
2248 (pMgmt->eCurrState == WMAC_STATE_JOINTED))
2249 bUpdateTSF = TRUE;
2250
2251 // During dpc, already in spinlocked.
2252 if (BSSDBbIsSTAInNodeDB(pMgmt, sFrame.pHdr->sA3.abyAddr2, &uNodeIndex)) {
2253
2254 // Update the STA, (Techically the Beacons of all the IBSS nodes
2255 // should be identical, but that's not happening in practice.
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 // Todo, initial Node content
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 //if (uNodeIndex == 0)
2296 {
2297 printk("s_vMgrRxBeacon:TxDataRate is %d,Index is %d\n",pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate,uNodeIndex);
2298 }
2299 #endif
2300 /*
2301 pMgmt->sNodeDBTable[uNodeIndex].bShortSlotTime = WLAN_GET_CAP_INFO_SHORTSLOTTIME(*sFrame.pwCapInfo);
2302 if(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate > RATE_11M)
2303 pMgmt->sNodeDBTable[uNodeIndex].bERPExist = TRUE;
2304 */
2305 }
2306
2307 // if other stations jointed, indicate connect to upper layer..
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 // See other adhoc sta with the same SSID but BSSID is different.
2323 // adpot this vars only when TSF larger then us.
2324 if (bTSFLargeDiff && bTSFOffsetPostive) {
2325 // we don't support ATIM under adhoc mode
2326 // if ( sFrame.pIBSSParms->wATIMWindow == 0) {
2327 // adpot this vars
2328 // TODO: check sFrame cap if privacy on, and support rate syn
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 // set HW beacon interval and re-synchronizing....
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 // Turn off bssid filter to avoid filter others adhoc station which bssid is different.
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 // MACvRegBitsOff(pDevice->PortOffset, MAC_REG_RCR, RCR_BSSID);
2353 // set highest basic rate
2354 // s_vSetHighestBasicRate(pDevice, (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates);
2355 // Prepare beacon frame
2356 bMgrPrepareBeaconToSend((HANDLE)pDevice, pMgmt);
2357 // }
2358 };
2359 }
2360 };
2361 // endian issue ???
2362 // Update TSF
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 * Routine Description:
2378 * Instructs the hw to create a bss using the supplied
2379 * attributes. Note that this implementation only supports Ad-Hoc
2380 * BSS creation.
2381 *
2382 *
2383 * Return Value:
2384 * CMD_STATUS
2385 *
2386 -*/
2387 VOID
2388 vMgrCreateOwnIBSS(
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 // encryption mode error
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 // Disable Protect Mode
2458 pDevice->bProtectMode = 0;
2459 MACvDisableProtectMD(pDevice->PortOffset);
2460
2461 pDevice->bBarkerPreambleMd = 0;
2462 MACvDisableBarkerPreambleMd(pDevice->PortOffset);
2463
2464 // Kyle Test 2003.11.04
2465
2466 // set HW beacon interval
2467 if (pMgmt->wIBSSBeaconPeriod == 0)
2468 pMgmt->wIBSSBeaconPeriod = DEFAULT_IBSS_BI;
2469
2470
2471 CARDbGetCurrentTSF(pDevice->PortOffset, &qwCurrTSF);
2472 // clear TSF counter
2473 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
2474 // enable TSF counter
2475 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
2476
2477 // set Next TBTT
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 // set basic rate
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 // Adopt pre-configured IBSS vars to current vars
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 //memcpy(pMgmt->abyDesireSSID,pMgmt->abyAdHocSSID,
2513 // ((PWLAN_IE_SSID)pMgmt->abyAdHocSSID)->len + WLAN_IEHDR_LEN);
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 // AP mode BSSID = MAC addr
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 // BSSID selected must be randomized as spec 11.1.3
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 // Set Capability Info
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 // memcpy(pDevice->abyBSSID, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
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 // set channel and clear NAV
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 // Prepare beacon to send
2632 if (bMgrPrepareBeaconToSend((HANDLE)pDevice, pMgmt)) {
2633 *pStatus = CMD_STATUS_SUCCESS;
2634 }
2635
2636 return ;
2637 }
2638
2639
2640
2641 /*+
2642 *
2643 * Routine Description:
2644 * Instructs wmac to join a bss using the supplied attributes.
2645 * The arguments may the BSSID or SSID and the rest of the
2646 * attributes are obtained from the scan result of known bss list.
2647 *
2648 *
2649 * Return Value:
2650 * None.
2651 *
2652 -*/
2653
2654 VOID
2655 vMgrJoinBSSBegin(
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 // memset(pMgmt->abyDesireBSSID, 0, WLAN_BSSID_LEN);
2688 // Search known BSS list for prefer BSSID or SSID
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 // patch for CISCO migration mode
2709 /*
2710 if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2711 if (WPA_SearchRSN(0, WPA_TKIP, pCurr) == FALSE) {
2712 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No match RSN info. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
2713 // encryption mode error
2714 pMgmt->eCurrState = WMAC_STATE_IDLE;
2715 return;
2716 }
2717 } else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2718 if (WPA_SearchRSN(0, WPA_AESCCMP, pCurr) == FALSE) {
2719 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No match RSN info. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
2720 // encryption mode error
2721 pMgmt->eCurrState = WMAC_STATE_IDLE;
2722 return;
2723 }
2724 }
2725 */
2726 }
2727
2728 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2729 //if(pDevice->bWPASuppWextEnabled == TRUE)
2730 Encyption_Rebuild(pDevice, pCurr);
2731 #endif
2732 // Infrastructure BSS
2733 s_vMgrSynchBSS(pDevice,
2734 WMAC_MODE_ESS_STA,
2735 pCurr,
2736 pStatus
2737 );
2738
2739 if (*pStatus == CMD_STATUS_SUCCESS){
2740
2741 // Adopt this BSS state vars in Mgmt Object
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 // Parse Support Rate IE
2755 pItemRates->byElementID = WLAN_EID_SUPP_RATES;
2756 pItemRates->len = RATEuSetIE((PWLAN_IE_SUPP_RATES)pCurr->abySuppRates,
2757 pItemRates,
2758 uRateLen);
2759
2760 // Parse Extension Support Rate IE
2761 pItemExtRates->byElementID = WLAN_EID_EXTSUPP_RATES;
2762 pItemExtRates->len = RATEuSetIE((PWLAN_IE_SUPP_RATES)pCurr->abyExtSuppRates,
2763 pItemExtRates,
2764 uRateLen);
2765 // Stuffing Rate IE
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 // TODO: deal with if wCapInfo the privacy is on, but station WEP is off
2789 // TODO: deal with if wCapInfo the PS-Pollable is on.
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 // Adopt BSS state in Adapter Device Object
2799 //pDevice->byOpMode = OP_MODE_INFRASTRUCTURE;
2800 // memcpy(pDevice->abyBSSID, pCurr->abyBSSID, WLAN_BSSID_LEN);
2801
2802 // Add current BSS to Candidate list
2803 // This should only works for WPA2 BSS, and WPA2 BSS check must be done before.
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 // Preamble type auto-switch: if AP can receive short-preamble cap,
2815 // we can turn on too.
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 // ad-hoc mode BSS
2831 if (pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) {
2832
2833 if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2834 if (WPA_SearchRSN(0, WPA_TKIP, pCurr) == FALSE) {
2835 // encryption mode error
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 // encryption mode error
2842 pMgmt->eCurrState = WMAC_STATE_IDLE;
2843 return;
2844 }
2845 } else {
2846 // encryption mode error
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 // Adopt this BSS state vars in Mgmt Object
2860 // TODO: check if CapInfo privacy on, but we don't..
2861 pMgmt->uCurrChannel = pCurr->uChannel;
2862
2863
2864 // Parse Support Rate IE
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 // set basic rate
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 // pMgmt->wCurrATIMWindow = pCurr->wATIMWindow;
2880 MACvWriteATIMW(pDevice->PortOffset, pMgmt->wCurrATIMWindow);
2881 pMgmt->eCurrMode = WMAC_MODE_IBSS_STA;
2882
2883 pMgmt->eCurrState = WMAC_STATE_STARTED;
2884 // Adopt BSS state in Adapter Device Object
2885 //pDevice->byOpMode = OP_MODE_ADHOC;
2886 // pDevice->bLinkPass = TRUE;
2887 // memcpy(pDevice->abyBSSID, pCurr->abyBSSID, WLAN_BSSID_LEN);
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 // Preamble type auto-switch: if AP can receive short-preamble cap,
2898 // and if registry setting is short preamble we can turn on too.
2899
2900 // Prepare beacon
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 * Routine Description:
2915 * Set HW to synchronize a specific BSS from known BSS list.
2916 *
2917 *
2918 * Return Value:
2919 * PCM_STATUS
2920 *
2921 -*/
2922 static
2923 VOID
2924 s_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 // int ii;
2934 //1M, 2M, 5M, 11M, 18M, 24M, 36M, 54M
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 //6M, 9M, 12M, 48M
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 // if previous mode is IBSS.
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 // Init the BSS informations
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 // Set Basic Rate
2970 CARDbAddBasicRate((PVOID)pDevice, RATE_1M);
2971 // calculate TSF offset
2972 // TSF Offset = Received Timestamp TSF - Marked Local's TSF
2973 CARDbUpdateTSF(pDevice, pCurr->byRxRate, pCurr->qwBSSTimestamp, pCurr->qwLocalTSF);
2974
2975 CARDbSetBeaconPeriod(pDevice, pCurr->wBeaconInterval);
2976
2977 // set Next TBTT
2978 // Next TBTT = ((local_current_TSF / beacon_interval) + 1 ) * beacon_interval
2979 CARDvSetFirstNextTBTT(pDevice->PortOffset, pCurr->wBeaconInterval);
2980
2981 // set BSSID
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 // Add current BSS to Candidate list
3035 // This should only works for WPA2 BSS, and WPA2 BSS check must be done before.
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 // set channel and clear NAV
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 for (ii=0;ii<BB_VGA_LEVEL;ii++) {
3061 if (pCurr->ldBmMAX< pDevice->ldBmThreshold[ii]) {
3062 pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
3063 break;
3064 }
3065 }
3066
3067 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
3068 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RSSI[%d] NewGain[%d] OldGain[%d] \n",
3069 (int)pCurr->ldBmMAX, pDevice->byBBVGANew, pDevice->byBBVGACurrent);
3070 printk("RSSI[%d] NewGain[%d] OldGain[%d] \n",
3071 (int)pCurr->ldBmMAX, pDevice->byBBVGANew, pDevice->byBBVGACurrent);
3072 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
3073 }
3074 printk("ldBmMAX[%d] NewGain[%d] OldGain[%d] \n",
3075 (int)pCurr->ldBmMAX, pDevice->byBBVGANew, pDevice->byBBVGACurrent);
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 //mike add: fix NetworkManager 0.7.0 hidden ssid mode in WPA encryption
3090 // ,need reset eAuthenMode and eEncryptionStatus
3091 static VOID Encyption_Rebuild(
3092 IN PSDevice pDevice,
3093 IN PKnownBSS pCurr
3094 )
3095 {
3096 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
3097 // UINT ii , uSameBssidNum=0;
3098
3099 // for (ii = 0; ii < MAX_BSS_NUM; ii++) {
3100 // if (pMgmt->sBSSList[ii].bActive &&
3101 // IS_ETH_ADDRESS_EQUAL(pMgmt->sBSSList[ii].abyBSSID, pCurr->abyBSSID)) {
3102 // uSameBssidNum++;
3103 // }
3104 // }
3105 // if( uSameBssidNum>=2) { //we only check AP in hidden sssid mode
3106 if ((pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK) || //networkmanager 0.7.0 does not give the pairwise-key selsection,
3107 (pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK)) { // so we need re-selsect it according to real pairwise-key info.
3108 if(pCurr->bWPAValid == TRUE) { //WPA-PSK
3109 pMgmt->eAuthenMode = WMAC_AUTH_WPAPSK;
3110 if(pCurr->abyPKType[0] == WPA_TKIP) {
3111 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled; //TKIP
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; //AES
3116 PRINT_K("Encyption_Rebuild--->ssid reset config to [WPAPSK-AES]\n");
3117 }
3118 }
3119 else if(pCurr->bWPA2Valid == TRUE) { //WPA2-PSK
3120 pMgmt->eAuthenMode = WMAC_AUTH_WPA2PSK;
3121 if(pCurr->abyCSSPK[0] == WLAN_11i_CSS_TKIP) {
3122 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled; //TKIP
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; //AES
3127 PRINT_K("Encyption_Rebuild--->ssid reset config to [WPA2PSK-AES]\n");
3128 }
3129 }
3130 }
3131 // }
3132 return;
3133 }
3134
3135
3136 /*+
3137 *
3138 * Routine Description:
3139 * Format TIM field
3140 *
3141 *
3142 * Return Value:
3143 * VOID
3144 *
3145 -*/
3146
3147 static
3148 VOID
3149 s_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 // Find size of partial virtual bitmap
3164 for (ii = 0; ii < (MAX_NODE_NUM + 1); ii++) {
3165 byMap = pMgmt->abyPSTxMap[ii];
3166 if (!ii) {
3167 // Mask out the broadcast bit which is indicated separately.
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 // Round start index down to nearest even number
3185 wStartIndex &= ~BIT0;
3186
3187 // Round end index up to nearest even number
3188 wEndIndex = ((wEndIndex + 1) & ~BIT0);
3189
3190 // Size of element payload
3191
3192 pTIM->len = 3 + (wEndIndex - wStartIndex) + 1;
3193
3194 // Fill in the Fixed parts of the TIM
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 // Append variable part of TIM
3201
3202 for (ii = wStartIndex, jj =0 ; ii <= wEndIndex; ii++, jj++) {
3203 pTIM->byVirtBitMap[jj] = pMgmt->abyPSTxMap[ii];
3204 }
3205
3206 // Aid = 0 don't used.
3207 pTIM->byVirtBitMap[0] &= ~BIT0;
3208 }
3209
3210
3211 /*+
3212 *
3213 * Routine Description:
3214 * Constructs an Beacon frame( Ad-hoc mode)
3215 *
3216 *
3217 * Return Value:
3218 * PTR to frame; or NULL on allocation failue
3219 *
3220 -*/
3221
3222 static
3223 PSTxMgmtPacket
3224 s_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 // prepare beacon frame
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 // Setup the sFrame structure.
3250 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3251 sFrame.len = WLAN_BEACON_FR_MAXLEN;
3252 vMgrEncodeBeacon(&sFrame);
3253 // Setup the header
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 // Copy SSID
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 // Copy the rate set
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 // DS parameter
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 // TIM field
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 // IBSS parameter
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 /* RSN parameter */
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;//AES
3322 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
3323 sFrame.pRSNWPA->abyMulticast[3] = 0x02;//TKIP
3324 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled)
3325 sFrame.pRSNWPA->abyMulticast[3] = 0x01;//WEP40
3326 else
3327 sFrame.pRSNWPA->abyMulticast[3] = 0x00;//NONE
3328
3329 // Pairwise Key Cipher Suite
3330 sFrame.pRSNWPA->wPKCount = 0;
3331 // Auth Key Management Suite
3332 *((PWORD)(sFrame.pBuf + sFrame.len + sFrame.pRSNWPA->len))=0;
3333 sFrame.pRSNWPA->len +=2;
3334
3335 // RSN Capabilites
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 // Country IE
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 // Power Constrain IE
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 // Channel Switch IE
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 // TPC report
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 // IBSS DFS
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 // hostapd wpa/wpa2 IE
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 /* Adjust the length fields */
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 * Routine Description:
3441 * Constructs an Prob-response frame
3442 *
3443 *
3444 * Return Value:
3445 * PTR to frame; or NULL on allocation failue
3446 *
3447 -*/
3448
3449
3450
3451
3452 PSTxMgmtPacket
3453 s_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 // Setup the sFrame structure.
3480 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3481 sFrame.len = WLAN_PROBERESP_FR_MAXLEN;
3482 vMgrEncodeProbeResponse(&sFrame);
3483 // Setup the header
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 // Copy SSID
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 // Copy the rate set
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 // DS parameter
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 // IBSS parameter
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 // Country IE
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 // Power Constrain IE
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 // Channel Switch IE
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 // TPC report
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 // IBSS DFS
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 // hostapd wpa/wpa2 IE
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 // Adjust the length fields
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 * Routine Description:
3632 * Constructs an association request frame
3633 *
3634 *
3635 * Return Value:
3636 * A ptr to frame or NULL on allocation failue
3637 *
3638 -*/
3639
3640
3641 PSTxMgmtPacket
3642 s_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 // Setup the sFrame structure.
3663 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3664 sFrame.len = WLAN_ASSOCREQ_FR_MAXLEN;
3665 // format fixed field frame structure
3666 vMgrEncodeAssocRequest(&sFrame);
3667 // Setup the header
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 // Set the capibility and listen interval
3678 *(sFrame.pwCapInfo) = cpu_to_le16(wCurrCapInfo);
3679 *(sFrame.pwListenInterval) = cpu_to_le16(wListenInterval);
3680
3681 // sFrame.len point to end of fixed field
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 // Copy the rate set
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 // Copy the extension rate set
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 // for 802.11h
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 /* WPA IE */
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 //Group Key Cipher Suite
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 // Pairwise Key Cipher Suite
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 // Auth Key Management Suite
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 // RSN Capabilites
3788
3789 *pbyRSN++=0x00;
3790 *pbyRSN++=0x00;
3791 sFrame.pRSNWPA->len +=2;
3792
3793 sFrame.len += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
3794 // copy to AssocInfo. for OID_802_11_ASSOCIATION_INFORMATION
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 // WPA IE
3806 sFrame.pRSN = (PWLAN_IE_RSN)(sFrame.pBuf + sFrame.len);
3807 sFrame.pRSN->byElementID = WLAN_EID_RSN;
3808 sFrame.pRSN->len = 6; //Version(2)+GK(4)
3809 sFrame.pRSN->wVersion = 1;
3810 //Group Key Cipher Suite
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 // Pairwise Key Cipher Suite
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 // Auth Key Management Suite
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 // RSN Capabilites
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 // RSN PMKID
3867 pbyRSN = &sFrame.pRSN->abyRSN[18];
3868 pwPMKID = (PWORD)pbyRSN; // Point to PMKID count
3869 *pwPMKID = 0; // Initialize PMKID count
3870 pbyRSN += 2; // Point to PMKID list
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 // copy to AssocInfo. for OID_802_11_ASSOCIATION_INFORMATION
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 // Adjust the length fields
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 * Routine Description:
3907 * Constructs an re-association request frame
3908 *
3909 *
3910 * Return Value:
3911 * A ptr to frame or NULL on allocation failue
3912 *
3913 -*/
3914
3915
3916 PSTxMgmtPacket
3917 s_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 /* Setup the sFrame structure. */
3938 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
3939 sFrame.len = WLAN_REASSOCREQ_FR_MAXLEN;
3940
3941 // format fixed field frame structure
3942 vMgrEncodeReassocRequest(&sFrame);
3943
3944 /* Setup the header */
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 /* Set the capibility and listen interval */
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 /* Copy the SSID */
3960 /* sFrame.len point to end of fixed field */
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 /* Copy the rate set */
3972 /* sFrame.len point to end of SSID */
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 // Copy the extension rate set
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 /* WPA IE */
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 //Group Key Cipher Suite
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 // Pairwise Key Cipher Suite
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 // Auth Key Management Suite
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 // RSN Capabilites
4045 *pbyRSN++=0x00;
4046 *pbyRSN++=0x00;
4047 sFrame.pRSNWPA->len +=2;
4048
4049 sFrame.len += sFrame.pRSNWPA->len + WLAN_IEHDR_LEN;
4050 // copy to AssocInfo. for OID_802_11_ASSOCIATION_INFORMATION
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 /* WPA IE */
4062 sFrame.pRSN = (PWLAN_IE_RSN)(sFrame.pBuf + sFrame.len);
4063 sFrame.pRSN->byElementID = WLAN_EID_RSN;
4064 sFrame.pRSN->len = 6; //Version(2)+GK(4)
4065 sFrame.pRSN->wVersion = 1;
4066 //Group Key Cipher Suite
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 // Pairwise Key Cipher Suite
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 // Auth Key Management Suite
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 // RSN Capabilites
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 // RSN PMKID
4123 pbyRSN = &sFrame.pRSN->abyRSN[18];
4124 pwPMKID = (PWORD)pbyRSN; // Point to PMKID count
4125 *pwPMKID = 0; // Initialize PMKID count
4126 pbyRSN += 2; // Point to PMKID list
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 // copy to AssocInfo. for OID_802_11_ASSOCIATION_INFORMATION
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 /* Adjust the length fields */
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 * Routine Description:
4159 * Constructs an assoc-response frame
4160 *
4161 *
4162 * Return Value:
4163 * PTR to frame; or NULL on allocation failue
4164 *
4165 -*/
4166
4167
4168 PSTxMgmtPacket
4169 s_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 // Setup the sFrame structure
4188 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
4189 sFrame.len = WLAN_REASSOCRESP_FR_MAXLEN;
4190 vMgrEncodeAssocResponse(&sFrame);
4191 // Setup the header
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 // Copy the rate set
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 // Adjust the length fields
4223 pTxPacket->cbMPDULen = sFrame.len;
4224 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
4225
4226 return pTxPacket;
4227 }
4228
4229
4230 /*+
4231 *
4232 * Routine Description:
4233 * Constructs an reassoc-response frame
4234 *
4235 *
4236 * Return Value:
4237 * PTR to frame; or NULL on allocation failue
4238 *
4239 -*/
4240
4241
4242 PSTxMgmtPacket
4243 s_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 // Setup the sFrame structure
4262 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
4263 sFrame.len = WLAN_REASSOCRESP_FR_MAXLEN;
4264 vMgrEncodeReassocResponse(&sFrame);
4265 // Setup the header
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 // Copy the rate set
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 // Adjust the length fields
4297 pTxPacket->cbMPDULen = sFrame.len;
4298 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
4299
4300 return pTxPacket;
4301 }
4302
4303
4304 /*+
4305 *
4306 * Routine Description:
4307 * Handles probe response management frames.
4308 *
4309 *
4310 * Return Value:
4311 * none.
4312 *
4313 -*/
4314
4315 static
4316 VOID
4317 s_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 // decode the frame
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 // channel remapping to
4353 byIEChannel = CARDbyGetChannelMapping(pMgmt->pAdapter, sFrame.pDSParms->byCurrChannel, PHY_TYPE_11A);
4354 } else {
4355 byIEChannel = sFrame.pDSParms->byCurrChannel;
4356 }
4357 if (byCurrChannel != byIEChannel) {
4358 // adjust channel info. bcs we rcv adjcent channel pakckets
4359 bChannelHit = FALSE;
4360 byCurrChannel = byIEChannel;
4361 }
4362 } else {
4363 // no DS channel info
4364 bChannelHit = TRUE;
4365 }
4366
4367 //2008-0730-01<Add>by MikeLiu
4368 if(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 // update or insert the bss
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, // payload of probresponse
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, // payload of beacon
4421 (HANDLE)pRxPacket
4422 );
4423 }
4424 return;
4425
4426 }
4427
4428 /*+
4429 *
4430 * Routine Description:(AP)or(Ad-hoc STA)
4431 * Handles probe request management frames.
4432 *
4433 *
4434 * Return Value:
4435 * none.
4436 *
4437 -*/
4438
4439
4440 static
4441 VOID
4442 s_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 // STA in Ad-hoc mode: when latest TBTT beacon transmit success,
4454 // STA have to response this request.
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 // decode the frame
4460 sFrame.len = pRxPacket->cbMPDULen;
4461 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
4462 vMgrDecodeProbeRequest(&sFrame);
4463 /*
4464 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Probe request rx:MAC addr:%02x-%02x-%02x=%02x-%02x-%02x \n",
4465 sFrame.pHdr->sA3.abyAddr2[0],
4466 sFrame.pHdr->sA3.abyAddr2[1],
4467 sFrame.pHdr->sA3.abyAddr2[2],
4468 sFrame.pHdr->sA3.abyAddr2[3],
4469 sFrame.pHdr->sA3.abyAddr2[4],
4470 sFrame.pHdr->sA3.abyAddr2[5]
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 // Probe response reply..
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 /* send the frame */
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 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Probe response tx sending..\n");
4511 }
4512 }
4513 }
4514
4515 return;
4516 }
4517
4518
4519
4520
4521
4522 /*+
4523 *
4524 * Routine Description:
4525 *
4526 * Entry point for the reception and handling of 802.11 management
4527 * frames. Makes a determination of the frame type and then calls
4528 * the appropriate function.
4529 *
4530 *
4531 * Return Value:
4532 * none.
4533 *
4534 -*/
4535
4536
4537 VOID
4538 vMgrRxManagePacket(
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 // Frame Clase = 2
4560 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx assocreq\n");
4561 if (eNodeState < NODE_AUTH) {
4562 // send deauth notification
4563 // reason = (6) class 2 received from nonauth sta
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 // Frame Clase = 2
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 // Frame Clase = 2
4586 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx reassocreq\n");
4587 // Todo: reassoc
4588 if (eNodeState < NODE_AUTH) {
4589 // send deauth notification
4590 // reason = (6) class 2 received from nonauth sta
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 // Frame Clase = 2
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 // Frame Clase = 0
4611 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx probereq\n");
4612 s_vMgrRxProbeRequest(pDevice, pMgmt, pRxPacket);
4613 break;
4614
4615 case WLAN_FSTYPE_PROBERESP:
4616 // Frame Clase = 0
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 // Frame Clase = 0
4624 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx beacon\n");
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 // Frame Clase = 1
4633 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx atim\n");
4634 break;
4635
4636 case WLAN_FSTYPE_DISASSOC:
4637 // Frame Clase = 2
4638 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx disassoc\n");
4639 if (eNodeState < NODE_AUTH) {
4640 // send deauth notification
4641 // reason = (6) class 2 received from nonauth sta
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 // Frame Clase = 1
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 // Frame Clase = 1
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 * Routine Description:
4678 *
4679 *
4680 * Prepare beacon to send
4681 *
4682 * Return Value:
4683 * TRUE if success; FALSE if failed.
4684 *
4685 -*/
4686 BOOL
4687 bMgrPrepareBeaconToSend(
4688 IN HANDLE hDeviceContext,
4689 IN PSMgmtObject pMgmt
4690 )
4691 {
4692 PSDevice pDevice = (PSDevice)hDeviceContext;
4693 PSTxMgmtPacket pTxPacket;
4694
4695 // pDevice->bBeaconBufReady = FALSE;
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, //0,
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 * Routine Description:
4731 *
4732 * Log a warning message based on the contents of the Status
4733 * Code field of an 802.11 management frame. Defines are
4734 * derived from 802.11-1997 SPEC.
4735 *
4736 * Return Value:
4737 * none.
4738 *
4739 -*/
4740 static
4741 VOID
4742 s_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 * Description:
4797 * Add BSSID in PMKID Candidate list.
4798 *
4799 * Parameters:
4800 * In:
4801 * hDeviceContext - device structure point
4802 * pbyBSSID - BSSID address for adding
4803 * wRSNCap - BSS's RSN capability
4804 * Out:
4805 * none
4806 *
4807 * Return Value: none.
4808 *
4809 -*/
4810 BOOL
4811 bAdd_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 // Update Old Candidate
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 // New Candidate
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 * Description:
4860 * Flush PMKID Candidate list.
4861 *
4862 * Parameters:
4863 * In:
4864 * hDeviceContext - device structure point
4865 * Out:
4866 * none
4867 *
4868 * Return Value: none.
4869 *
4870 -*/
4871 VOID
4872 vFlush_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
4884 static BOOL
4885 s_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 // check cap. of BSS
4900 if ((WLAN_GET_CAP_INFO_PRIVACY(pBSSNode->wCapInfo) != 0) &&
4901 (EncStatus == Ndis802_11Encryption1Enabled)) {
4902 // default is WEP only
4903 byMulticastCipher = KEY_CTL_WEP;
4904 }
4905
4906 if ((WLAN_GET_CAP_INFO_PRIVACY(pBSSNode->wCapInfo) != 0) &&
4907 (pBSSNode->bWPA2Valid == TRUE) &&
4908 //20080123-01,<Add> by Einsn Liu
4909 ((EncStatus == Ndis802_11Encryption3Enabled)||(EncStatus == Ndis802_11Encryption2Enabled))) {
4910 //WPA2
4911 // check Group Key Cipher
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 // check Pairwise Key Cipher
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 // this should not happen as defined 802.11i
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 // use group key only ignore all others
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 //WPA
4944 // check Group Key Cipher
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 // check Pairwise Key Cipher
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 // use group key only ignore all others
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 // mask our cap. with BSS
4974 if (EncStatus == Ndis802_11Encryption1Enabled) {
4975
4976 // For supporting Cisco migration mode, don't care pairwise key cipher
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 // When CCMP is enable, "Use group cipher suite" shall not be a valid option.
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
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree