git.oblomov.eu Git - linux-2.6/blob - drivers/staging/vt6655/wmgr.c

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