PageRenderTime 74ms CodeModel.GetById 21ms app.highlight 40ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/staging/vt6656/wmgr.c

https://bitbucket.org/wisechild/galaxy-nexus
C | 4895 lines | 3452 code | 597 blank | 846 comment | 901 complexity | 62d115cf82bfe43686bc621b5cf510e5 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

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

Large files files are truncated, but you can click here to view the full file