/drivers/staging/vt6656/wmgr.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 4895 lines · 3452 code · 597 blank · 846 comment · 904 complexity · 62d115cf82bfe43686bc621b5cf510e5 MD5 · raw file

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