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