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