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