/drivers/staging/vt6656/wmgr.c
C | 4895 lines | 3452 code | 597 blank | 846 comment | 901 complexity | 62d115cf82bfe43686bc621b5cf510e5 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
Large files files are truncated, but you can click here to view the full file
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 --------------------------*/
91static int msglevel =MSG_LEVEL_INFO;
92//static int msglevel =MSG_LEVEL_DEBUG;
93
94/*--------------------- Static Functions --------------------------*/
95
96static BOOL ChannelExceedZoneType(
97 PSDevice pDevice,
98 BYTE byCurrChannel
99 );
100
101// Association/diassociation functions
102static
103PSTxMgmtPacket
104s_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
115static
116void
117s_vMgrRxAssocRequest(
118 PSDevice pDevice,
119 PSMgmtObject pMgmt,
120 PSRxMgmtPacket pRxPacket,
121 unsigned int uNodeIndex
122 );
123
124static
125PSTxMgmtPacket
126s_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
137static
138void
139s_vMgrRxAssocResponse(
140 PSDevice pDevice,
141 PSMgmtObject pMgmt,
142 PSRxMgmtPacket pRxPacket,
143 BOOL bReAssocType
144 );
145
146static
147void
148s_vMgrRxDisassociation(
149 PSDevice pDevice,
150 PSMgmtObject pMgmt,
151 PSRxMgmtPacket pRxPacket
152 );
153
154// Authentication/deauthen functions
155static
156void
157s_vMgrRxAuthenSequence_1(
158 PSDevice pDevice,
159 PSMgmtObject pMgmt,
160 PWLAN_FR_AUTHEN pFrame
161 );
162
163static
164void
165s_vMgrRxAuthenSequence_2(
166 PSDevice pDevice,
167 PSMgmtObject pMgmt,
168 PWLAN_FR_AUTHEN pFrame
169 );
170
171static
172void
173s_vMgrRxAuthenSequence_3(
174 PSDevice pDevice,
175 PSMgmtObject pMgmt,
176 PWLAN_FR_AUTHEN pFrame
177 );
178
179static
180void
181s_vMgrRxAuthenSequence_4(
182 PSDevice pDevice,
183 PSMgmtObject pMgmt,
184 PWLAN_FR_AUTHEN pFrame
185 );
186
187static
188void
189s_vMgrRxAuthentication(
190 PSDevice pDevice,
191 PSMgmtObject pMgmt,
192 PSRxMgmtPacket pRxPacket
193 );
194
195static
196void
197s_vMgrRxDeauthentication(
198 PSDevice pDevice,
199 PSMgmtObject pMgmt,
200 PSRxMgmtPacket pRxPacket
201 );
202
203// Scan functions
204// probe request/response functions
205static
206void
207s_vMgrRxProbeRequest(
208 PSDevice pDevice,
209 PSMgmtObject pMgmt,
210 PSRxMgmtPacket pRxPacket
211 );
212
213static
214void
215s_vMgrRxProbeResponse(
216 PSDevice pDevice,
217 PSMgmtObject pMgmt,
218 PSRxMgmtPacket pRxPacket
219 );
220
221// beacon functions
222static
223void
224s_vMgrRxBeacon(
225 PSDevice pDevice,
226 PSMgmtObject pMgmt,
227 PSRxMgmtPacket pRxPacket,
228 BOOL bInScan
229 );
230
231static
232void
233s_vMgrFormatTIM(
234 PSMgmtObject pMgmt,
235 PWLAN_IE_TIM pTIM
236 );
237
238static
239PSTxMgmtPacket
240s_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
255static
256PSTxMgmtPacket
257s_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
269static
270PSTxMgmtPacket
271s_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
283static
284PSTxMgmtPacket
285s_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
301static
302void
303s_vMgrLogStatus(
304 PSMgmtObject pMgmt,
305 WORD wStatus
306 );
307
308
309static
310void
311s_vMgrSynchBSS (
312 PSDevice pDevice,
313 unsigned int uBSSMode,
314 PKnownBSS pCurr,
315 PCMD_STATUS pStatus
316 );
317
318
319static BOOL
320s_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
346void 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 init_timer(&pDevice->sTimerTxData);
377 pDevice->sTimerTxData.data = (unsigned long)pDevice;
378 pDevice->sTimerTxData.function = (TimerFunction)BSSvSecondTxData;
379 pDevice->sTimerTxData.expires = RUN_AT(10*HZ); //10s callback
380 pDevice->fTxDataInSleep = FALSE;
381 pDevice->IsTxDataTrigger = FALSE;
382 pDevice->nTxDataTimeCout = 0;
383
384 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
385 pDevice->uCmdDequeueIdx = 0;
386 pDevice->uCmdEnqueueIdx = 0;
387 pDevice->eCommandState = WLAN_CMD_IDLE;
388 pDevice->bCmdRunning = FALSE;
389 pDevice->bCmdClear = FALSE;
390
391 return;
392}
393
394/*+
395 *
396 * Routine Description:
397 * Start the station association procedure. Namely, send an
398 * association request frame to the AP.
399 *
400 * Return Value:
401 * None.
402 *
403-*/
404
405void vMgrAssocBeginSta(void *hDeviceContext,
406 PSMgmtObject pMgmt,
407 PCMD_STATUS pStatus)
408{
409 PSDevice pDevice = (PSDevice)hDeviceContext;
410 PSTxMgmtPacket pTxPacket;
411
412
413 pMgmt->wCurrCapInfo = 0;
414 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_ESS(1);
415 if (pDevice->bEncryptionEnable) {
416 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_PRIVACY(1);
417 }
418 // always allow receive short preamble
419 //if (pDevice->byPreambleType == 1) {
420 // pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
421 //}
422 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
423 if (pMgmt->wListenInterval == 0)
424 pMgmt->wListenInterval = 1; // at least one.
425
426 // ERP Phy (802.11g) should support short preamble.
427 if (pMgmt->eCurrentPHYMode == PHY_TYPE_11G) {
428 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
429 if (pDevice->bShortSlotTime == TRUE)
430 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
431
432 } else if (pMgmt->eCurrentPHYMode == PHY_TYPE_11B) {
433 if (pDevice->byPreambleType == 1) {
434 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
435 }
436 }
437 if (pMgmt->b11hEnable == TRUE)
438 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SPECTRUMMNG(1);
439
440 // build an assocreq frame and send it
441 pTxPacket = s_MgrMakeAssocRequest
442 (
443 pDevice,
444 pMgmt,
445 pMgmt->abyCurrBSSID,
446 pMgmt->wCurrCapInfo,
447 pMgmt->wListenInterval,
448 (PWLAN_IE_SSID)pMgmt->abyCurrSSID,
449 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
450 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
451 );
452
453 if (pTxPacket != NULL ){
454 // send the frame
455 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
456 if (*pStatus == CMD_STATUS_PENDING) {
457 pMgmt->eCurrState = WMAC_STATE_ASSOCPENDING;
458 *pStatus = CMD_STATUS_SUCCESS;
459 }
460 }
461 else
462 *pStatus = CMD_STATUS_RESOURCES;
463
464 return ;
465}
466
467
468/*+
469 *
470 * Routine Description:
471 * Start the station re-association procedure.
472 *
473 * Return Value:
474 * None.
475 *
476-*/
477
478void vMgrReAssocBeginSta(void *hDeviceContext,
479 PSMgmtObject pMgmt,
480 PCMD_STATUS pStatus)
481{
482 PSDevice pDevice = (PSDevice)hDeviceContext;
483 PSTxMgmtPacket pTxPacket;
484
485
486
487 pMgmt->wCurrCapInfo = 0;
488 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_ESS(1);
489 if (pDevice->bEncryptionEnable) {
490 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_PRIVACY(1);
491 }
492
493 //if (pDevice->byPreambleType == 1) {
494 // pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
495 //}
496 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
497
498 if (pMgmt->wListenInterval == 0)
499 pMgmt->wListenInterval = 1; // at least one.
500
501
502 // ERP Phy (802.11g) should support short preamble.
503 if (pMgmt->eCurrentPHYMode == PHY_TYPE_11G) {
504 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
505 if (pDevice->bShortSlotTime == TRUE)
506 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
507
508 } else if (pMgmt->eCurrentPHYMode == PHY_TYPE_11B) {
509 if (pDevice->byPreambleType == 1) {
510 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTPREAMBLE(1);
511 }
512 }
513 if (pMgmt->b11hEnable == TRUE)
514 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SPECTRUMMNG(1);
515
516
517 pTxPacket = s_MgrMakeReAssocRequest
518 (
519 pDevice,
520 pMgmt,
521 pMgmt->abyCurrBSSID,
522 pMgmt->wCurrCapInfo,
523 pMgmt->wListenInterval,
524 (PWLAN_IE_SSID)pMgmt->abyCurrSSID,
525 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
526 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
527 );
528
529 if (pTxPacket != NULL ){
530 // send the frame
531 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
532 if (*pStatus != CMD_STATUS_PENDING) {
533 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Reassociation tx failed.\n");
534 }
535 else {
536 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Reassociation tx sending.\n");
537 }
538 }
539
540
541 return ;
542}
543
544/*+
545 *
546 * Routine Description:
547 * Send an dis-association request frame to the AP.
548 *
549 * Return Value:
550 * None.
551 *
552-*/
553
554void vMgrDisassocBeginSta(void *hDeviceContext,
555 PSMgmtObject pMgmt,
556 PBYTE abyDestAddress,
557 WORD wReason,
558 PCMD_STATUS pStatus)
559{
560 PSDevice pDevice = (PSDevice)hDeviceContext;
561 PSTxMgmtPacket pTxPacket = NULL;
562 WLAN_FR_DISASSOC sFrame;
563
564 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
565 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_DISASSOC_FR_MAXLEN);
566 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
567
568 // Setup the sFrame structure
569 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
570 sFrame.len = WLAN_DISASSOC_FR_MAXLEN;
571
572 // format fixed field frame structure
573 vMgrEncodeDisassociation(&sFrame);
574
575 // Setup the header
576 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
577 (
578 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
579 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_DISASSOC)
580 ));
581
582 memcpy( sFrame.pHdr->sA3.abyAddr1, abyDestAddress, WLAN_ADDR_LEN);
583 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
584 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
585
586 // Set reason code
587 *(sFrame.pwReason) = cpu_to_le16(wReason);
588 pTxPacket->cbMPDULen = sFrame.len;
589 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
590
591 // send the frame
592 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
593 if (*pStatus == CMD_STATUS_PENDING) {
594 pMgmt->eCurrState = WMAC_STATE_IDLE;
595 *pStatus = CMD_STATUS_SUCCESS;
596 }
597
598 return;
599}
600
601
602
603/*+
604 *
605 * Routine Description:(AP function)
606 * Handle incoming station association request frames.
607 *
608 * Return Value:
609 * None.
610 *
611-*/
612
613static
614void
615s_vMgrRxAssocRequest(
616 PSDevice pDevice,
617 PSMgmtObject pMgmt,
618 PSRxMgmtPacket pRxPacket,
619 unsigned int uNodeIndex
620 )
621{
622 WLAN_FR_ASSOCREQ sFrame;
623 CMD_STATUS Status;
624 PSTxMgmtPacket pTxPacket;
625 WORD wAssocStatus = 0;
626 WORD wAssocAID = 0;
627 unsigned int uRateLen = WLAN_RATES_MAXLEN;
628 BYTE abyCurrSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
629 BYTE abyCurrExtSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
630
631
632 if (pMgmt->eCurrMode != WMAC_MODE_ESS_AP)
633 return;
634 // node index not found
635 if (!uNodeIndex)
636 return;
637
638 //check if node is authenticated
639 //decode the frame
640 memset(&sFrame, 0, sizeof(WLAN_FR_ASSOCREQ));
641 memset(abyCurrSuppRates, 0, WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
642 memset(abyCurrExtSuppRates, 0, WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1);
643 sFrame.len = pRxPacket->cbMPDULen;
644 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
645
646 vMgrDecodeAssocRequest(&sFrame);
647
648 if (pMgmt->sNodeDBTable[uNodeIndex].eNodeState >= NODE_AUTH) {
649 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_ASSOC;
650 pMgmt->sNodeDBTable[uNodeIndex].wCapInfo = cpu_to_le16(*sFrame.pwCapInfo);
651 pMgmt->sNodeDBTable[uNodeIndex].wListenInterval = cpu_to_le16(*sFrame.pwListenInterval);
652 pMgmt->sNodeDBTable[uNodeIndex].bPSEnable =
653 WLAN_GET_FC_PWRMGT(sFrame.pHdr->sA3.wFrameCtl) ? TRUE : FALSE;
654 // Todo: check sta basic rate, if ap can't support, set status code
655 if (pDevice->byBBType == BB_TYPE_11B) {
656 uRateLen = WLAN_RATES_MAXLEN_11B;
657 }
658 abyCurrSuppRates[0] = WLAN_EID_SUPP_RATES;
659 abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
660 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
661 uRateLen);
662 abyCurrExtSuppRates[0] = WLAN_EID_EXTSUPP_RATES;
663 if (pDevice->byBBType == BB_TYPE_11G) {
664 abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pExtSuppRates,
665 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
666 uRateLen);
667 } else {
668 abyCurrExtSuppRates[1] = 0;
669 }
670
671
672 RATEvParseMaxRate((void *)pDevice,
673 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
674 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
675 FALSE, // do not change our basic rate
676 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxBasicRate),
677 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate),
678 &(pMgmt->sNodeDBTable[uNodeIndex].wSuppRate),
679 &(pMgmt->sNodeDBTable[uNodeIndex].byTopCCKBasicRate),
680 &(pMgmt->sNodeDBTable[uNodeIndex].byTopOFDMBasicRate)
681 );
682
683 // set max tx rate
684 pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate =
685 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate;
686 // Todo: check sta preamble, if ap can't support, set status code
687 pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble =
688 WLAN_GET_CAP_INFO_SHORTPREAMBLE(*sFrame.pwCapInfo);
689 pMgmt->sNodeDBTable[uNodeIndex].bShortSlotTime =
690 WLAN_GET_CAP_INFO_SHORTSLOTTIME(*sFrame.pwCapInfo);
691 pMgmt->sNodeDBTable[uNodeIndex].wAID = (WORD)uNodeIndex;
692 wAssocStatus = WLAN_MGMT_STATUS_SUCCESS;
693 wAssocAID = (WORD)uNodeIndex;
694 // check if ERP support
695 if(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate > RATE_11M)
696 pMgmt->sNodeDBTable[uNodeIndex].bERPExist = TRUE;
697
698 if (pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate <= RATE_11M) {
699 // B only STA join
700 pDevice->bProtectMode = TRUE;
701 pDevice->bNonERPPresent = TRUE;
702 }
703 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble == FALSE) {
704 pDevice->bBarkerPreambleMd = TRUE;
705 }
706
707 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Associate AID= %d \n", wAssocAID);
708 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "MAC=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \n",
709 sFrame.pHdr->sA3.abyAddr2[0],
710 sFrame.pHdr->sA3.abyAddr2[1],
711 sFrame.pHdr->sA3.abyAddr2[2],
712 sFrame.pHdr->sA3.abyAddr2[3],
713 sFrame.pHdr->sA3.abyAddr2[4],
714 sFrame.pHdr->sA3.abyAddr2[5]
715 ) ;
716 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Max Support rate = %d \n",
717 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate);
718 }
719
720
721 // assoc response reply..
722 pTxPacket = s_MgrMakeAssocResponse
723 (
724 pDevice,
725 pMgmt,
726 pMgmt->wCurrCapInfo,
727 wAssocStatus,
728 wAssocAID,
729 sFrame.pHdr->sA3.abyAddr2,
730 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
731 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
732 );
733 if (pTxPacket != NULL ){
734
735 if (pDevice->bEnableHostapd) {
736 return;
737 }
738 /* send the frame */
739 Status = csMgmt_xmit(pDevice, pTxPacket);
740 if (Status != CMD_STATUS_PENDING) {
741 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Assoc response tx failed\n");
742 }
743 else {
744 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Assoc response tx sending..\n");
745 }
746
747 }
748
749 return;
750}
751
752
753/*+
754 *
755 * Description:(AP function)
756 * Handle incoming station re-association request frames.
757 *
758 * Parameters:
759 * In:
760 * pMgmt - Management Object structure
761 * pRxPacket - Received Packet
762 * Out:
763 * none
764 *
765 * Return Value: None.
766 *
767-*/
768
769static
770void
771s_vMgrRxReAssocRequest(
772 PSDevice pDevice,
773 PSMgmtObject pMgmt,
774 PSRxMgmtPacket pRxPacket,
775 unsigned int uNodeIndex
776 )
777{
778 WLAN_FR_REASSOCREQ sFrame;
779 CMD_STATUS Status;
780 PSTxMgmtPacket pTxPacket;
781 WORD wAssocStatus = 0;
782 WORD wAssocAID = 0;
783 unsigned int uRateLen = WLAN_RATES_MAXLEN;
784 BYTE abyCurrSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
785 BYTE abyCurrExtSuppRates[WLAN_IEHDR_LEN + WLAN_RATES_MAXLEN + 1];
786
787 if (pMgmt->eCurrMode != WMAC_MODE_ESS_AP)
788 return;
789 // node index not found
790 if (!uNodeIndex)
791 return;
792 //check if node is authenticated
793 //decode the frame
794 memset(&sFrame, 0, sizeof(WLAN_FR_REASSOCREQ));
795 sFrame.len = pRxPacket->cbMPDULen;
796 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
797 vMgrDecodeReassocRequest(&sFrame);
798
799 if (pMgmt->sNodeDBTable[uNodeIndex].eNodeState >= NODE_AUTH) {
800 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_ASSOC;
801 pMgmt->sNodeDBTable[uNodeIndex].wCapInfo = cpu_to_le16(*sFrame.pwCapInfo);
802 pMgmt->sNodeDBTable[uNodeIndex].wListenInterval = cpu_to_le16(*sFrame.pwListenInterval);
803 pMgmt->sNodeDBTable[uNodeIndex].bPSEnable =
804 WLAN_GET_FC_PWRMGT(sFrame.pHdr->sA3.wFrameCtl) ? TRUE : FALSE;
805 // Todo: check sta basic rate, if ap can't support, set status code
806
807 if (pDevice->byBBType == BB_TYPE_11B) {
808 uRateLen = WLAN_RATES_MAXLEN_11B;
809 }
810
811 abyCurrSuppRates[0] = WLAN_EID_SUPP_RATES;
812 abyCurrSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pSuppRates,
813 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
814 uRateLen);
815 abyCurrExtSuppRates[0] = WLAN_EID_EXTSUPP_RATES;
816 if (pDevice->byBBType == BB_TYPE_11G) {
817 abyCurrExtSuppRates[1] = RATEuSetIE((PWLAN_IE_SUPP_RATES)sFrame.pExtSuppRates,
818 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
819 uRateLen);
820 } else {
821 abyCurrExtSuppRates[1] = 0;
822 }
823
824
825 RATEvParseMaxRate((void *)pDevice,
826 (PWLAN_IE_SUPP_RATES)abyCurrSuppRates,
827 (PWLAN_IE_SUPP_RATES)abyCurrExtSuppRates,
828 FALSE, // do not change our basic rate
829 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxBasicRate),
830 &(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate),
831 &(pMgmt->sNodeDBTable[uNodeIndex].wSuppRate),
832 &(pMgmt->sNodeDBTable[uNodeIndex].byTopCCKBasicRate),
833 &(pMgmt->sNodeDBTable[uNodeIndex].byTopOFDMBasicRate)
834 );
835
836 // set max tx rate
837 pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate =
838 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate;
839 // Todo: check sta preamble, if ap can't support, set status code
840 pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble =
841 WLAN_GET_CAP_INFO_SHORTPREAMBLE(*sFrame.pwCapInfo);
842 pMgmt->sNodeDBTable[uNodeIndex].bShortSlotTime =
843 WLAN_GET_CAP_INFO_SHORTSLOTTIME(*sFrame.pwCapInfo);
844 pMgmt->sNodeDBTable[uNodeIndex].wAID = (WORD)uNodeIndex;
845 wAssocStatus = WLAN_MGMT_STATUS_SUCCESS;
846 wAssocAID = (WORD)uNodeIndex;
847
848 // if suppurt ERP
849 if(pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate > RATE_11M)
850 pMgmt->sNodeDBTable[uNodeIndex].bERPExist = TRUE;
851
852 if (pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate <= RATE_11M) {
853 // B only STA join
854 pDevice->bProtectMode = TRUE;
855 pDevice->bNonERPPresent = TRUE;
856 }
857 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble == FALSE) {
858 pDevice->bBarkerPreambleMd = TRUE;
859 }
860
861 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Rx ReAssociate AID= %d \n", wAssocAID);
862 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "MAC=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \n",
863 sFrame.pHdr->sA3.abyAddr2[0],
864 sFrame.pHdr->sA3.abyAddr2[1],
865 sFrame.pHdr->sA3.abyAddr2[2],
866 sFrame.pHdr->sA3.abyAddr2[3],
867 sFrame.pHdr->sA3.abyAddr2[4],
868 sFrame.pHdr->sA3.abyAddr2[5]
869 ) ;
870 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Max Support rate = %d \n",
871 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate);
872
873 }
874
875
876 // assoc response reply..
877 pTxPacket = s_MgrMakeReAssocResponse
878 (
879 pDevice,
880 pMgmt,
881 pMgmt->wCurrCapInfo,
882 wAssocStatus,
883 wAssocAID,
884 sFrame.pHdr->sA3.abyAddr2,
885 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates,
886 (PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates
887 );
888
889 if (pTxPacket != NULL ){
890 /* send the frame */
891 if (pDevice->bEnableHostapd) {
892 return;
893 }
894 Status = csMgmt_xmit(pDevice, pTxPacket);
895 if (Status != CMD_STATUS_PENDING) {
896 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:ReAssoc response tx failed\n");
897 }
898 else {
899 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:ReAssoc response tx sending..\n");
900 }
901 }
902 return;
903}
904
905
906/*+
907 *
908 * Routine Description:
909 * Handle incoming association response frames.
910 *
911 * Return Value:
912 * None.
913 *
914-*/
915
916static
917void
918s_vMgrRxAssocResponse(
919 PSDevice pDevice,
920 PSMgmtObject pMgmt,
921 PSRxMgmtPacket pRxPacket,
922 BOOL bReAssocType
923 )
924{
925 WLAN_FR_ASSOCRESP sFrame;
926 PWLAN_IE_SSID pItemSSID;
927 PBYTE pbyIEs;
928 viawget_wpa_header *wpahdr;
929
930
931
932 if (pMgmt->eCurrState == WMAC_STATE_ASSOCPENDING ||
933 pMgmt->eCurrState == WMAC_STATE_ASSOC) {
934
935 sFrame.len = pRxPacket->cbMPDULen;
936 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
937 // decode the frame
938 vMgrDecodeAssocResponse(&sFrame);
939 if ((sFrame.pwCapInfo == NULL)
940 || (sFrame.pwStatus == NULL)
941 || (sFrame.pwAid == NULL)
942 || (sFrame.pSuppRates == NULL)) {
943 DBG_PORT80(0xCC);
944 return;
945 }
946
947 pMgmt->sAssocInfo.AssocInfo.ResponseFixedIEs.Capabilities = *(sFrame.pwCapInfo);
948 pMgmt->sAssocInfo.AssocInfo.ResponseFixedIEs.StatusCode = *(sFrame.pwStatus);
949 pMgmt->sAssocInfo.AssocInfo.ResponseFixedIEs.AssociationId = *(sFrame.pwAid);
950 pMgmt->sAssocInfo.AssocInfo.AvailableResponseFixedIEs |= 0x07;
951
952 pMgmt->sAssocInfo.AssocInfo.ResponseIELength = sFrame.len - 24 - 6;
953 pMgmt->sAssocInfo.AssocInfo.OffsetResponseIEs = pMgmt->sAssocInfo.AssocInfo.OffsetRequestIEs + pMgmt->sAssocInfo.AssocInfo.RequestIELength;
954 pbyIEs = pMgmt->sAssocInfo.abyIEs;
955 pbyIEs += pMgmt->sAssocInfo.AssocInfo.RequestIELength;
956 memcpy(pbyIEs, (sFrame.pBuf + 24 +6), pMgmt->sAssocInfo.AssocInfo.ResponseIELength);
957
958 // save values and set current BSS state
959 if (cpu_to_le16((*(sFrame.pwStatus))) == WLAN_MGMT_STATUS_SUCCESS ){
960 // set AID
961 pMgmt->wCurrAID = cpu_to_le16((*(sFrame.pwAid)));
962 if ( (pMgmt->wCurrAID >> 14) != (BIT0 | BIT1) )
963 {
964 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "AID from AP, has two msb clear.\n");
965 }
966 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Association Successful, AID=%d.\n", pMgmt->wCurrAID & ~(BIT14|BIT15));
967 pMgmt->eCurrState = WMAC_STATE_ASSOC;
968 BSSvUpdateAPNode((void *) pDevice,
969 sFrame.pwCapInfo,
970 sFrame.pSuppRates,
971 sFrame.pExtSuppRates);
972 pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
973 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "Link with AP(SSID): %s\n", pItemSSID->abySSID);
974 pDevice->bLinkPass = TRUE;
975 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_INTER);
976 if ((pDevice->bWPADEVUp) && (pDevice->skb != NULL)) {
977 if(skb_tailroom(pDevice->skb) <(sizeof(viawget_wpa_header)+pMgmt->sAssocInfo.AssocInfo.ResponseIELength+
978 pMgmt->sAssocInfo.AssocInfo.RequestIELength)) { //data room not enough
979 dev_kfree_skb(pDevice->skb);
980 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
981 }
982 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
983 wpahdr->type = VIAWGET_ASSOC_MSG;
984 wpahdr->resp_ie_len = pMgmt->sAssocInfo.AssocInfo.ResponseIELength;
985 wpahdr->req_ie_len = pMgmt->sAssocInfo.AssocInfo.RequestIELength;
986 memcpy(pDevice->skb->data + sizeof(viawget_wpa_header), pMgmt->sAssocInfo.abyIEs, wpahdr->req_ie_len);
987 memcpy(pDevice->skb->data + sizeof(viawget_wpa_header) + wpahdr->req_ie_len,
988 pbyIEs,
989 wpahdr->resp_ie_len
990 );
991 skb_put(pDevice->skb, sizeof(viawget_wpa_header) + wpahdr->resp_ie_len + wpahdr->req_ie_len);
992 pDevice->skb->dev = pDevice->wpadev;
993 skb_reset_mac_header(pDevice->skb);
994 pDevice->skb->pkt_type = PACKET_HOST;
995 pDevice->skb->protocol = htons(ETH_P_802_2);
996 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
997 netif_rx(pDevice->skb);
998 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
999 }
1000
1001#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1002 //if(pDevice->bWPASuppWextEnabled == TRUE)
1003 {
1004 BYTE buf[512];
1005 size_t len;
1006 union iwreq_data wrqu;
1007 int we_event;
1008
1009 memset(buf, 0, 512);
1010
1011 len = pMgmt->sAssocInfo.AssocInfo.RequestIELength;
1012 if(len) {
1013 memcpy(buf, pMgmt->sAssocInfo.abyIEs, len);
1014 memset(&wrqu, 0, sizeof (wrqu));
1015 wrqu.data.length = len;
1016 we_event = IWEVASSOCREQIE;
1017 PRINT_K("wireless_send_event--->IWEVASSOCREQIE\n");
1018 wireless_send_event(pDevice->dev, we_event, &wrqu, buf);
1019 }
1020
1021 memset(buf, 0, 512);
1022 len = pMgmt->sAssocInfo.AssocInfo.ResponseIELength;
1023
1024 if(len) {
1025 memcpy(buf, pbyIEs, len);
1026 memset(&wrqu, 0, sizeof (wrqu));
1027 wrqu.data.length = len;
1028 we_event = IWEVASSOCRESPIE;
1029 PRINT_K("wireless_send_event--->IWEVASSOCRESPIE\n");
1030 wireless_send_event(pDevice->dev, we_event, &wrqu, buf);
1031 }
1032
1033 memset(&wrqu, 0, sizeof (wrqu));
1034 memcpy(wrqu.ap_addr.sa_data, &pMgmt->abyCurrBSSID[0], ETH_ALEN);
1035 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1036 PRINT_K("wireless_send_event--->SIOCGIWAP(associated)\n");
1037 wireless_send_event(pDevice->dev, SIOCGIWAP, &wrqu, NULL);
1038
1039 }
1040#endif //#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1041
1042 }
1043 else {
1044 if (bReAssocType) {
1045 pMgmt->eCurrState = WMAC_STATE_IDLE;
1046 }
1047 else {
1048 // jump back to the auth state and indicate the error
1049 pMgmt->eCurrState = WMAC_STATE_AUTH;
1050 }
1051 s_vMgrLogStatus(pMgmt,cpu_to_le16((*(sFrame.pwStatus))));
1052 }
1053
1054 }
1055
1056#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1057//need clear flags related to Networkmanager
1058 pDevice->bwextstep0 = FALSE;
1059 pDevice->bwextstep1 = FALSE;
1060 pDevice->bwextstep2 = FALSE;
1061 pDevice->bwextstep3 = FALSE;
1062 pDevice->bWPASuppWextEnabled = FALSE;
1063#endif
1064
1065if(pMgmt->eCurrState == WMAC_STATE_ASSOC)
1066 timer_expire(pDevice->sTimerCommand, 0);
1067
1068 return;
1069}
1070
1071/*+
1072 *
1073 * Routine Description:
1074 * Start the station authentication procedure. Namely, send an
1075 * authentication frame to the AP.
1076 *
1077 * Return Value:
1078 * None.
1079 *
1080-*/
1081
1082void vMgrAuthenBeginSta(void *hDeviceContext,
1083 PSMgmtObject pMgmt,
1084 PCMD_STATUS pStatus)
1085{
1086 PSDevice pDevice = (PSDevice)hDeviceContext;
1087 WLAN_FR_AUTHEN sFrame;
1088 PSTxMgmtPacket pTxPacket = NULL;
1089
1090 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1091 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1092 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1093 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1094 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1095 vMgrEncodeAuthen(&sFrame);
1096 /* insert values */
1097 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1098 (
1099 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1100 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)
1101 ));
1102 memcpy( sFrame.pHdr->sA3.abyAddr1, pMgmt->abyCurrBSSID, WLAN_ADDR_LEN);
1103 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1104 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1105 if (pMgmt->bShareKeyAlgorithm)
1106 *(sFrame.pwAuthAlgorithm) = cpu_to_le16(WLAN_AUTH_ALG_SHAREDKEY);
1107 else
1108 *(sFrame.pwAuthAlgorithm) = cpu_to_le16(WLAN_AUTH_ALG_OPENSYSTEM);
1109
1110 *(sFrame.pwAuthSequence) = cpu_to_le16(1);
1111 /* Adjust the length fields */
1112 pTxPacket->cbMPDULen = sFrame.len;
1113 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1114
1115 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
1116 if (*pStatus == CMD_STATUS_PENDING){
1117 pMgmt->eCurrState = WMAC_STATE_AUTHPENDING;
1118 *pStatus = CMD_STATUS_SUCCESS;
1119 }
1120
1121 return ;
1122}
1123
1124/*+
1125 *
1126 * Routine Description:
1127 * Start the station(AP) deauthentication procedure. Namely, send an
1128 * deauthentication frame to the AP or Sta.
1129 *
1130 * Return Value:
1131 * None.
1132 *
1133-*/
1134
1135void vMgrDeAuthenBeginSta(void *hDeviceContext,
1136 PSMgmtObject pMgmt,
1137 PBYTE abyDestAddress,
1138 WORD wReason,
1139 PCMD_STATUS pStatus)
1140{
1141 PSDevice pDevice = (PSDevice)hDeviceContext;
1142 WLAN_FR_DEAUTHEN sFrame;
1143 PSTxMgmtPacket pTxPacket = NULL;
1144
1145
1146 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1147 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_DEAUTHEN_FR_MAXLEN);
1148 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1149 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1150 sFrame.len = WLAN_DEAUTHEN_FR_MAXLEN;
1151 vMgrEncodeDeauthen(&sFrame);
1152 /* insert values */
1153 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1154 (
1155 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1156 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_DEAUTHEN)
1157 ));
1158
1159 memcpy( sFrame.pHdr->sA3.abyAddr1, abyDestAddress, WLAN_ADDR_LEN);
1160 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1161 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1162
1163 *(sFrame.pwReason) = cpu_to_le16(wReason); // deauthen. bcs left BSS
1164 /* Adjust the length fields */
1165 pTxPacket->cbMPDULen = sFrame.len;
1166 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1167
1168 *pStatus = csMgmt_xmit(pDevice, pTxPacket);
1169 if (*pStatus == CMD_STATUS_PENDING){
1170 *pStatus = CMD_STATUS_SUCCESS;
1171 }
1172
1173
1174 return ;
1175}
1176
1177
1178/*+
1179 *
1180 * Routine Description:
1181 * Handle incoming authentication frames.
1182 *
1183 * Return Value:
1184 * None.
1185 *
1186-*/
1187
1188static
1189void
1190s_vMgrRxAuthentication(
1191 PSDevice pDevice,
1192 PSMgmtObject pMgmt,
1193 PSRxMgmtPacket pRxPacket
1194 )
1195{
1196 WLAN_FR_AUTHEN sFrame;
1197
1198 // we better be an AP or a STA in AUTHPENDING otherwise ignore
1199 if (!(pMgmt->eCurrMode == WMAC_MODE_ESS_AP ||
1200 pMgmt->eCurrState == WMAC_STATE_AUTHPENDING)) {
1201 return;
1202 }
1203
1204 // decode the frame
1205 sFrame.len = pRxPacket->cbMPDULen;
1206 sFrame.pBuf = (PBYTE)pRxPacket->p80211Header;
1207 vMgrDecodeAuthen(&sFrame);
1208 switch (cpu_to_le16((*(sFrame.pwAuthSequence )))){
1209 case 1:
1210 //AP funciton
1211 s_vMgrRxAuthenSequence_1(pDevice,pMgmt, &sFrame);
1212 break;
1213 case 2:
1214 s_vMgrRxAuthenSequence_2(pDevice, pMgmt, &sFrame);
1215 break;
1216 case 3:
1217 //AP funciton
1218 s_vMgrRxAuthenSequence_3(pDevice, pMgmt, &sFrame);
1219 break;
1220 case 4:
1221 s_vMgrRxAuthenSequence_4(pDevice, pMgmt, &sFrame);
1222 break;
1223 default:
1224 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Auth Sequence error, seq = %d\n",
1225 cpu_to_le16((*(sFrame.pwAuthSequence))));
1226 break;
1227 }
1228 return;
1229}
1230
1231
1232
1233/*+
1234 *
1235 * Routine Description:
1236 * Handles incoming authen frames with sequence 1. Currently
1237 * assumes we're an AP. So far, no one appears to use authentication
1238 * in Ad-Hoc mode.
1239 *
1240 * Return Value:
1241 * None.
1242 *
1243-*/
1244
1245
1246static
1247void
1248s_vMgrRxAuthenSequence_1(
1249 PSDevice pDevice,
1250 PSMgmtObject pMgmt,
1251 PWLAN_FR_AUTHEN pFrame
1252 )
1253{
1254 PSTxMgmtPacket pTxPacket = NULL;
1255 unsigned int uNodeIndex;
1256 WLAN_FR_AUTHEN sFrame;
1257 PSKeyItem pTransmitKey;
1258
1259 // Insert a Node entry
1260 if (!BSSbIsSTAInNodeDB(pDevice, pFrame->pHdr->sA3.abyAddr2, &uNodeIndex)) {
1261 BSSvCreateOneNode((PSDevice)pDevice, &uNodeIndex);
1262 memcpy(pMgmt->sNodeDBTable[uNodeIndex].abyMACAddr, pFrame->pHdr->sA3.abyAddr2,
1263 WLAN_ADDR_LEN);
1264 }
1265
1266 if (pMgmt->bShareKeyAlgorithm) {
1267 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_KNOWN;
1268 pMgmt->sNodeDBTable[uNodeIndex].byAuthSequence = 1;
1269 }
1270 else {
1271 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_AUTH;
1272 }
1273
1274 // send auth reply
1275 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1276 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1277 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1278 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1279 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1280 // format buffer structure
1281 vMgrEncodeAuthen(&sFrame);
1282 // insert values
1283 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1284 (
1285 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1286 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)|
1287 WLAN_SET_FC_ISWEP(0)
1288 ));
1289 memcpy( sFrame.pHdr->sA3.abyAddr1, pFrame->pHdr->sA3.abyAddr2, WLAN_ADDR_LEN);
1290 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1291 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1292 *(sFrame.pwAuthAlgorithm) = *(pFrame->pwAuthAlgorithm);
1293 *(sFrame.pwAuthSequence) = cpu_to_le16(2);
1294
1295 if (cpu_to_le16(*(pFrame->pwAuthAlgorithm)) == WLAN_AUTH_ALG_SHAREDKEY) {
1296 if (pMgmt->bShareKeyAlgorithm)
1297 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_SUCCESS);
1298 else
1299 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_UNSUPPORTED_AUTHALG);
1300 }
1301 else {
1302 if (pMgmt->bShareKeyAlgorithm)
1303 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_UNSUPPORTED_AUTHALG);
1304 else
1305 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_SUCCESS);
1306 }
1307
1308 if (pMgmt->bShareKeyAlgorithm &&
1309 (cpu_to_le16(*(sFrame.pwStatus)) == WLAN_MGMT_STATUS_SUCCESS)) {
1310
1311 sFrame.pChallenge = (PWLAN_IE_CHALLENGE)(sFrame.pBuf + sFrame.len);
1312 sFrame.len += WLAN_CHALLENGE_IE_LEN;
1313 sFrame.pChallenge->byElementID = WLAN_EID_CHALLENGE;
1314 sFrame.pChallenge->len = WLAN_CHALLENGE_LEN;
1315 memset(pMgmt->abyChallenge, 0, WLAN_CHALLENGE_LEN);
1316 // get group key
1317 if(KeybGetTransmitKey(&(pDevice->sKey), pDevice->abyBroadcastAddr, GROUP_KEY, &pTransmitKey) == TRUE) {
1318 rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength+3);
1319 rc4_encrypt(&pDevice->SBox, pMgmt->abyChallenge, pMgmt->abyChallenge, WLAN_CHALLENGE_LEN);
1320 }
1321 memcpy(sFrame.pChallenge->abyChallenge, pMgmt->abyChallenge , WLAN_CHALLENGE_LEN);
1322 }
1323
1324 /* Adjust the length fields */
1325 pTxPacket->cbMPDULen = sFrame.len;
1326 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1327 // send the frame
1328 if (pDevice->bEnableHostapd) {
1329 return;
1330 }
1331 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Authreq_reply sequence_1 tx.. \n");
1332 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) {
1333 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Authreq_reply sequence_1 tx failed.\n");
1334 }
1335 return;
1336}
1337
1338
1339
1340/*+
1341 *
1342 * Routine Description:
1343 * Handles incoming auth frames with sequence number 2. Currently
1344 * assumes we're a station.
1345 *
1346 *
1347 * Return Value:
1348 * None.
1349 *
1350-*/
1351
1352static
1353void
1354s_vMgrRxAuthenSequence_2(
1355 PSDevice pDevice,
1356 PSMgmtObject pMgmt,
1357 PWLAN_FR_AUTHEN pFrame
1358 )
1359{
1360 WLAN_FR_AUTHEN sFrame;
1361 PSTxMgmtPacket pTxPacket = NULL;
1362
1363
1364 switch (cpu_to_le16((*(pFrame->pwAuthAlgorithm))))
1365 {
1366 case WLAN_AUTH_ALG_OPENSYSTEM:
1367 if ( cpu_to_le16((*(pFrame->pwStatus))) == WLAN_MGMT_STATUS_SUCCESS ){
1368 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (OPEN) Successful.\n");
1369 pMgmt->eCurrState = WMAC_STATE_AUTH;
1370 timer_expire(pDevice->sTimerCommand, 0);
1371 }
1372 else {
1373 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (OPEN) Failed.\n");
1374 s_vMgrLogStatus(pMgmt, cpu_to_le16((*(pFrame->pwStatus))));
1375 pMgmt->eCurrState = WMAC_STATE_IDLE;
1376 }
1377 if (pDevice->eCommandState == WLAN_AUTHENTICATE_WAIT) {
1378 /* spin_unlock_irq(&pDevice->lock);
1379 vCommandTimerWait((void *) pDevice, 0);
1380 spin_lock_irq(&pDevice->lock); */
1381 }
1382 break;
1383
1384 case WLAN_AUTH_ALG_SHAREDKEY:
1385
1386 if (cpu_to_le16((*(pFrame->pwStatus))) == WLAN_MGMT_STATUS_SUCCESS) {
1387 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1388 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1389 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1390 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1391 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1392 // format buffer structure
1393 vMgrEncodeAuthen(&sFrame);
1394 // insert values
1395 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1396 (
1397 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1398 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)|
1399 WLAN_SET_FC_ISWEP(1)
1400 ));
1401 memcpy( sFrame.pHdr->sA3.abyAddr1, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1402 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1403 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1404 *(sFrame.pwAuthAlgorithm) = *(pFrame->pwAuthAlgorithm);
1405 *(sFrame.pwAuthSequence) = cpu_to_le16(3);
1406 *(sFrame.pwStatus) = cpu_to_le16(WLAN_MGMT_STATUS_SUCCESS);
1407 sFrame.pChallenge = (PWLAN_IE_CHALLENGE)(sFrame.pBuf + sFrame.len);
1408 sFrame.len += WLAN_CHALLENGE_IE_LEN;
1409 sFrame.pChallenge->byElementID = WLAN_EID_CHALLENGE;
1410 sFrame.pChallenge->len = WLAN_CHALLENGE_LEN;
1411 memcpy( sFrame.pChallenge->abyChallenge, pFrame->pChallenge->abyChallenge, WLAN_CHALLENGE_LEN);
1412 // Adjust the length fields
1413 pTxPacket->cbMPDULen = sFrame.len;
1414 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1415 // send the frame
1416 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) {
1417 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Auth_reply sequence_2 tx failed.\n");
1418 }
1419 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Auth_reply sequence_2 tx ...\n");
1420 }
1421 else {
1422 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:rx Auth_reply sequence_2 status error ...\n");
1423 if ( pDevice->eCommandState == WLAN_AUTHENTICATE_WAIT ) {
1424 /* spin_unlock_irq(&pDevice->lock);
1425 vCommandTimerWait((void *) pDevice, 0);
1426 spin_lock_irq(&pDevice->lock); */
1427 }
1428 s_vMgrLogStatus(pMgmt, cpu_to_le16((*(pFrame->pwStatus))));
1429 }
1430 break;
1431 default:
1432 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt: rx auth.seq = 2 unknown AuthAlgorithm=%d\n", cpu_to_le16((*(pFrame->pwAuthAlgorithm))));
1433 break;
1434 }
1435 return;
1436}
1437
1438
1439
1440/*+
1441 *
1442 * Routine Description:
1443 * Handles incoming authen frames with sequence 3. Currently
1444 * assumes we're an AP. This function assumes the frame has
1445 * already been successfully decrypted.
1446 *
1447 *
1448 * Return Value:
1449 * None.
1450 *
1451-*/
1452
1453static
1454void
1455s_vMgrRxAuthenSequence_3(
1456 PSDevice pDevice,
1457 PSMgmtObject pMgmt,
1458 PWLAN_FR_AUTHEN pFrame
1459 )
1460{
1461 PSTxMgmtPacket pTxPacket = NULL;
1462 unsigned int uStatusCode = 0 ;
1463 unsigned int uNodeIndex = 0;
1464 WLAN_FR_AUTHEN sFrame;
1465
1466 if (!WLAN_GET_FC_ISWEP(pFrame->pHdr->sA3.wFrameCtl)) {
1467 uStatusCode = WLAN_MGMT_STATUS_CHALLENGE_FAIL;
1468 goto reply;
1469 }
1470 if (BSSbIsSTAInNodeDB(pDevice, pFrame->pHdr->sA3.abyAddr2, &uNodeIndex)) {
1471 if (pMgmt->sNodeDBTable[uNodeIndex].byAuthSequence != 1) {
1472 uStatusCode = WLAN_MGMT_STATUS_RX_AUTH_NOSEQ;
1473 goto reply;
1474 }
1475 if (memcmp(pMgmt->abyChallenge, pFrame->pChallenge->abyChallenge, WLAN_CHALLENGE_LEN) != 0) {
1476 uStatusCode = WLAN_MGMT_STATUS_CHALLENGE_FAIL;
1477 goto reply;
1478 }
1479 }
1480 else {
1481 uStatusCode = WLAN_MGMT_STATUS_UNSPEC_FAILURE;
1482 goto reply;
1483 }
1484
1485 if (uNodeIndex) {
1486 pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_AUTH;
1487 pMgmt->sNodeDBTable[uNodeIndex].byAuthSequence = 0;
1488 }
1489 uStatusCode = WLAN_MGMT_STATUS_SUCCESS;
1490 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Challenge text check ok..\n");
1491
1492reply:
1493 // send auth reply
1494 pTxPacket = (PSTxMgmtPacket)pMgmt->pbyMgmtPacketPool;
1495 memset(pTxPacket, 0, sizeof(STxMgmtPacket) + WLAN_AUTHEN_FR_MAXLEN);
1496 pTxPacket->p80211Header = (PUWLAN_80211HDR)((PBYTE)pTxPacket + sizeof(STxMgmtPacket));
1497 sFrame.pBuf = (PBYTE)pTxPacket->p80211Header;
1498 sFrame.len = WLAN_AUTHEN_FR_MAXLEN;
1499 // format buffer structure
1500 vMgrEncodeAuthen(&sFrame);
1501 /* insert values */
1502 sFrame.pHdr->sA3.wFrameCtl = cpu_to_le16(
1503 (
1504 WLAN_SET_FC_FTYPE(WLAN_TYPE_MGR) |
1505 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_AUTHEN)|
1506 WLAN_SET_FC_ISWEP(0)
1507 ));
1508 memcpy( sFrame.pHdr->sA3.abyAddr1, pFrame->pHdr->sA3.abyAddr2, WLAN_ADDR_LEN);
1509 memcpy( sFrame.pHdr->sA3.abyAddr2, pMgmt->abyMACAddr, WLAN_ADDR_LEN);
1510 memcpy( sFrame.pHdr->sA3.abyAddr3, pMgmt->abyCurrBSSID, WLAN_BSSID_LEN);
1511 *(sFrame.pwAuthAlgorithm) = *(pFrame->pwAuthAlgorithm);
1512 *(sFrame.pwAuthSequence) = cpu_to_le16(4);
1513 *(sFrame.pwStatus) = cpu_to_le16(uStatusCode);
1514
1515 /* Adjust the length fields */
1516 pTxPacket->cbMPDULen = sFrame.len;
1517 pTxPacket->cbPayloadLen = sFrame.len - WLAN_HDR_ADDR3_LEN;
1518 // send the frame
1519 if (pDevice->bEnableHostapd) {
1520 return;
1521 }
1522 if (csMgmt_xmit(pDevice, pTxPacket) != CMD_STATUS_PENDING) {
1523 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Mgt:Authreq_reply sequence_4 tx failed.\n");
1524 }
1525 return;
1526
1527}
1528
1529
1530
1531/*+
1532 *
1533 * Routine Description:
1534 * Handles incoming authen frames with sequence 4
1535 *
1536 *
1537 * Return Value:
1538 * None.
1539 *
1540-*/
1541static
1542void
1543s_vMgrRxAuthenSequence_4(
1544 PSDevice pDevice,
1545 PSMgmtObject pMgmt,
1546 PWLAN_FR_AUTHEN pFrame
1547 )
1548{
1549
1550 if ( cpu_to_le16((*(pFrame->pwStatus))) == WLAN_MGMT_STATUS_SUCCESS ){
1551 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (SHAREDKEY) Successful.\n");
1552 pMgmt->eCurrState = WMAC_STATE_AUTH;
1553 timer_expire(pDevice->sTimerCommand, 0);
1554 }
1555 else{
1556 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "802.11 Authen (SHAREDKEY) Failed.\n");
1557 s_vMgrLogStatus(pMgmt, cpu_to_le16((*(pFrame->pwStatus))) );
1558 pMgmt->eCurrState = WMAC_STATE_IDLE;
1559 }
1560
1561 if ( pDevice->eCommandState == WLAN_AUTHENTICATE_WAIT ) {
1562 /* spin_unlock_irq(&pDevice->lock);
1563 vCommand…
Large files files are truncated, but you can click here to view the full file