1/* 2 * mlmeSm.c 3 * 4 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name Texas Instruments nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34/** \file mlmeSM.c 35 * \brief 802.11 MLME SM source 36 * 37 * \see mlmeSM.h 38 */ 39 40 41/***************************************************************************/ 42/* */ 43/* MODULE: mlmeSM.c */ 44/* PURPOSE: 802.11 MLME SM source */ 45/* */ 46/***************************************************************************/ 47 48#define __FILE_ID__ FILE_ID_69 49#include "osApi.h" 50#include "paramOut.h" 51#include "fsm.h" 52#include "report.h" 53#include "smeApi.h" 54#include "AssocSM.h" 55#include "authSm.h" 56#include "mlmeBuilder.h" 57#include "mlmeSm.h" 58#include "openAuthSm.h" 59#include "sharedKeyAuthSm.h" 60#include "connApi.h" 61#include "DrvMainModules.h" 62 63 64#ifdef TI_DBG 65#include "siteMgrApi.h" 66#endif 67/* Constants */ 68 69/* Enumerations */ 70 71/* Typedefs */ 72 73/* Structures */ 74 75/* External data definitions */ 76 77/* External functions definitions */ 78 79/* Global variables */ 80 81/* Local function prototypes */ 82static void mlme_stopAssocAndAuth(mlme_t *pMlme); 83 84/* functions */ 85 86/** 87* 88* mlme_Create - allocate memory for MLME SM 89* 90* \b Description: 91* 92* Allocate memory for MLME SM. \n 93* Allocates memory for MLME context. \n 94* Allocates memory for MLME timer. \n 95* Allocates memory for MLME SM matrix. \n 96* 97* \b ARGS: 98* 99* I - pOs - OS context \n 100* 101* \b RETURNS: 102* 103* TI_OK if successful, TI_NOK otherwise. 104* 105* \sa rsn_mainSecSmKeysOnlyStop() 106*/ 107TI_HANDLE mlme_create(TI_HANDLE hOs) 108{ 109 mlme_t *pHandle; 110 TI_STATUS status; 111 112 /* allocate MLME context memory */ 113 pHandle = (mlme_t*)os_memoryAlloc(hOs, sizeof(mlme_t)); 114 if (pHandle == NULL) 115 { 116 return NULL; 117 } 118 119 /* zero all MLME context */ 120 os_memoryZero(hOs, pHandle, sizeof(mlme_t)); 121 122 pHandle->hOs = hOs; 123 124 /* allocate memory for MLME state machine */ 125 status = fsm_Create(hOs, &pHandle->pMlmeSm, MLME_SM_NUM_STATES, MLME_SM_NUM_EVENTS); 126 if (status != TI_OK) 127 { 128 os_memoryFree(hOs, pHandle, sizeof(mlme_t)); 129 return NULL; 130 } 131 132 return pHandle; 133} 134 135 136/** 137* 138* mlme_Unload - unload MLME SM from memory 139* 140* \b Description: 141* 142* Unload MLME SM from memory 143* 144* \b ARGS: 145* 146* I - hMlme - MLME SM context \n 147* 148* \b RETURNS: 149* 150* TI_OK if successful, TI_NOK otherwise. 151* 152* \sa rsn_mainSecSmKeysOnlyStop() 153*/ 154TI_STATUS mlme_unload(TI_HANDLE hMlme) 155{ 156 TI_STATUS status; 157 mlme_t *pHandle; 158 159 pHandle = (mlme_t*)hMlme; 160 161 status = fsm_Unload(pHandle->hOs, pHandle->pMlmeSm); 162 if (status != TI_OK) 163 { 164 /* report failure but don't stop... */ 165 } 166 167 os_memoryFree(pHandle->hOs, hMlme, sizeof(mlme_t)); 168 169 return TI_OK; 170} 171 172/** 173* 174* mlme_smConfig - configure a new MLME SM 175* 176* \b Description: 177* 178* Configure a new MLME SM and other modules handles. 179* 180* \b RETURNS: 181* 182* void 183* 184* \sa mlme_Create, mlme_Unload 185*/ 186void mlme_init (TStadHandlesList *pStadHandles) 187{ 188 mlme_t *pHandle = (mlme_t *)(pStadHandles->hMlmeSm); 189 190 /** Main 802.1X State Machine matrix */ 191 fsm_actionCell_t mlme_smMatrix[MLME_SM_NUM_STATES][MLME_SM_NUM_EVENTS] = 192 { 193 /* next state and actions for IDLE state */ 194 {{MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smStartIdle}, /* MLME_SM_EVENT_START */ 195 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smNOP}, /* MLME_SM_EVENT_STOP */ 196 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_SUCCESS */ 197 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_FAIL */ 198 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_ASSOC_SUCCESS */ 199 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected} /* MLME_SM_EVENT_ASSOC_FAIL */ 200 }, 201 /* next state and actions for AUTH_WAIT state */ 202 {{MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_START */ 203 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smNOP}, /* MLME_SM_EVENT_STOP */ 204 {MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smAuthSuccessAuthWait}, /* MLME_SM_EVENT_AUTH_SUCCESS */ 205 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smAuthFailAuthWait}, /* MLME_SM_EVENT_AUTH_FAIL */ 206 {MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_ASSOC_SUCCESS */ 207 {MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smActionUnexpected} /* MLME_SM_EVENT_ASSOC_FAIL */ 208 }, 209 /* next state and actions for ASSOC_WAIT state */ 210 {{MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_START */ 211 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smStopAssocWait}, /* MLME_SM_EVENT_STOP */ 212 {MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_SUCCESS */ 213 {MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_FAIL */ 214 {MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smAssocSuccessAssocWait}, /* MLME_SM_EVENT_ASSOC_SUCCESS */ 215 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smAssocFailAssocWait} /* MLME_SM_EVENT_ASSOC_FAIL */ 216 }, 217 /* next state and actions for ASSOC state */ 218 {{MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_START */ 219 {MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smStopAssoc}, /* MLME_SM_EVENT_STOP */ 220 {MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_SUCCESS */ 221 {MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_FAIL */ 222 {MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_ASSOC_SUCCESS */ 223 {MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected} /* MLME_SM_EVENT_ASSOC_FAIL */ 224 } 225 }; 226 227 fsm_Config(pHandle->pMlmeSm, &mlme_smMatrix[0][0], MLME_SM_NUM_STATES, MLME_SM_NUM_EVENTS, mlme_smEvent, pStadHandles->hOs); 228 229 pHandle->currentState = MLME_SM_STATE_IDLE; 230 pHandle->legacyAuthType = AUTH_LEGACY_NONE; 231 pHandle->reAssoc = TI_FALSE; 232 pHandle->disConnType = DISCONNECT_IMMEDIATE; 233 pHandle->disConnReason = STATUS_UNSPECIFIED; 234 235 pHandle->hAssoc = pStadHandles->hAssoc; 236 pHandle->hAuth = pStadHandles->hAuth; 237 pHandle->hSiteMgr = pStadHandles->hSiteMgr; 238 pHandle->hCtrlData = pStadHandles->hCtrlData; 239 pHandle->hTxMgmtQ = pStadHandles->hTxMgmtQ; 240 pHandle->hMeasurementMgr = pStadHandles->hMeasurementMgr; 241 pHandle->hSwitchChannel = pStadHandles->hSwitchChannel; 242 pHandle->hRegulatoryDomain = pStadHandles->hRegulatoryDomain; 243 pHandle->hReport = pStadHandles->hReport; 244 pHandle->hOs = pStadHandles->hOs; 245 pHandle->hConn = pStadHandles->hConn; 246 pHandle->hCurrBss = pStadHandles->hCurrBss; 247 pHandle->hApConn = pStadHandles->hAPConnection; 248 pHandle->hScanCncn = pStadHandles->hScanCncn; 249 pHandle->hQosMngr = pStadHandles->hQosMngr; 250 pHandle->hTWD = pStadHandles->hTWD; 251 pHandle->hTxCtrl = pStadHandles->hTxCtrl; 252 253 /* 254 debug info 255 */ 256 pHandle->debug_lastProbeRspTSFTime = 0; 257 pHandle->debug_lastDtimBcnTSFTime = 0; 258 pHandle->debug_lastBeaconTSFTime = 0; 259 pHandle->debug_isFunctionFirstTime = TI_TRUE; 260 pHandle->BeaconsCounterPS = 0; 261} 262 263void mlme_SetDefaults (TI_HANDLE hMlmeSm, TMlmeInitParams *pMlmeInitParams) 264{ 265 mlme_t *pMlme = (mlme_t *)(hMlmeSm); 266 267 /* set default values */ 268 pMlme->bParseBeaconWSC = pMlmeInitParams->parseWSCInBeacons; 269} 270 271TI_STATUS mlme_setParam(TI_HANDLE hMlmeSm, 272 paramInfo_t *pParam) 273{ 274 mlme_t *pMlmeSm = (mlme_t *)hMlmeSm; 275 276 switch(pParam->paramType) 277 { 278 case MLME_LEGACY_TYPE_PARAM: 279 280 switch (pParam->content.mlmeLegacyAuthType) 281 { 282 case AUTH_LEGACY_RESERVED1: 283 case AUTH_LEGACY_OPEN_SYSTEM: 284 /* First configure the MLME with the new legacy authentication type */ 285 pMlmeSm->legacyAuthType = pParam->content.mlmeLegacyAuthType; 286 /* Now configure the authentication module. */ 287 pParam->paramType = AUTH_LEGACY_TYPE_PARAM; 288 return auth_setParam(pMlmeSm->hAuth, pParam); 289 290 case AUTH_LEGACY_SHARED_KEY: 291 /* First configure the MLME with the new legacy authentication type */ 292 pMlmeSm->legacyAuthType = AUTH_LEGACY_SHARED_KEY; 293 /* Now configure the authentication module. */ 294 pParam->paramType = AUTH_LEGACY_TYPE_PARAM; 295 return auth_setParam(pMlmeSm->hAuth, pParam); 296 297 case AUTH_LEGACY_AUTO_SWITCH: 298 /* First configure the MLME with the new legacy authentication type */ 299 pMlmeSm->legacyAuthType = AUTH_LEGACY_AUTO_SWITCH; 300 /* Now configure the authentication module, 301 Auto switch mode means start always with shared key, if fail move to open system. */ 302 pParam->paramType = AUTH_LEGACY_TYPE_PARAM; 303 pParam->content.authLegacyAuthType = AUTH_LEGACY_SHARED_KEY; 304 return auth_setParam(pMlmeSm->hAuth, pParam); 305 306 default: 307 TRACE1(pMlmeSm->hReport, REPORT_SEVERITY_ERROR, "Set param, Params is not supported, 0x%x\n\n", pParam->content.mlmeLegacyAuthType); 308 return PARAM_VALUE_NOT_VALID; 309 } 310/* break; - unreachable */ 311 312 case MLME_RE_ASSOC_PARAM: 313 pMlmeSm->reAssoc = pParam->content.mlmeReAssoc; 314 break; 315 316 default: 317 TRACE1(pMlmeSm->hReport, REPORT_SEVERITY_ERROR, "Set param, Params is not supported, 0x%x\n\n", pParam->paramType); 318 return PARAM_NOT_SUPPORTED; 319 } 320 321 return TI_OK; 322} 323 324TI_STATUS mlme_getParam(TI_HANDLE hMlmeSm, 325 paramInfo_t *pParam) 326{ 327 mlme_t *pMlmeSm = (mlme_t *)hMlmeSm; 328 329 switch(pParam->paramType) 330 { 331 case MLME_LEGACY_TYPE_PARAM: 332 pParam->content.mlmeLegacyAuthType = pMlmeSm->legacyAuthType; 333 break; 334 335 case MLME_CAPABILITY_PARAM: 336 pParam->content.mlmeLegacyAuthType = pMlmeSm->legacyAuthType; 337 assoc_smCapBuild(pMlmeSm->hAssoc, &(pParam->content.siteMgrSiteCapability)); 338 break; 339 340 case MLME_BEACON_RECV: 341 pParam->content.siteMgrTiWlanCounters.BeaconsRecv = pMlmeSm->BeaconsCounterPS; 342 break; 343 344 default: 345 TRACE1(pMlmeSm->hReport, REPORT_SEVERITY_ERROR, "Get param, Params is not supported, %d\n\n", pParam->content.mlmeLegacyAuthType); 346 return PARAM_NOT_SUPPORTED; 347 } 348 349 return TI_OK; 350} 351 352/** 353* 354* mlme_Start - Start event for the MLME SM 355* 356* \b Description: 357* 358* Start event for the MLME SM 359* 360* \b ARGS: 361* 362* I - hMlme - MLME SM context \n 363* 364* \b RETURNS: 365* 366* TI_OK if successful, TI_NOK otherwise. 367* 368* \sa mlme_Stop, mlme_Recv 369*/ 370TI_STATUS mlme_start(TI_HANDLE hMlme) 371{ 372 TI_STATUS status; 373 mlme_t *pHandle = (mlme_t*)hMlme; 374 375 if (pHandle == NULL) 376 { 377 return TI_NOK; 378 } 379 380 if (pHandle->legacyAuthType == AUTH_LEGACY_NONE) 381 { 382 TRACE0(pHandle->hReport, REPORT_SEVERITY_ERROR, "mlme_start: pHandle->legacyAuthType == AUTH_LEGACY_NONE\n"); 383 return TI_NOK; 384 } 385 386 status = mlme_smEvent(&pHandle->currentState, MLME_SM_EVENT_START, pHandle); 387 388 return status; 389} 390 391/** 392* 393* mlme_Stop - Stop event for the MLME SM 394* 395* \b Description: 396* 397* Stop event for the MLME SM 398* 399* \b ARGS: 400* 401* I - hMlme - MLME SM context \n 402* 403* \b RETURNS: 404* 405* TI_OK if successful, TI_NOK otherwise. 406* 407* \sa mlme_Start, mlme_Recv 408*/ 409TI_STATUS mlme_stop(TI_HANDLE hMlme, DisconnectType_e disConnType, mgmtStatus_e reason) 410{ 411 TI_STATUS status; 412 mlme_t *pHandle; 413 414 pHandle = (mlme_t*)hMlme; 415 416 if (pHandle->legacyAuthType == AUTH_LEGACY_NONE) 417 return TI_NOK; 418 419 pHandle->disConnType = disConnType; 420 pHandle->disConnReason = reason; 421 422 status = mlme_smEvent(&pHandle->currentState, MLME_SM_EVENT_STOP, pHandle); 423 424 return status; 425} 426 427 428/** 429* 430* mlme_reportAuthStatus - Set a specific parameter to the MLME SM 431* 432* \b Description: 433* 434* Set a specific parameter to the MLME SM. 435* 436* \b ARGS: 437* 438* I - hMlme - MLME SM context \n 439* I/O - pParam - Parameter \n 440* 441* \b RETURNS: 442* 443* TI_OK if successful, TI_NOK otherwise. 444* 445* \sa mlme_Start, mlme_Stop 446*/ 447TI_STATUS mlme_reportAuthStatus(TI_HANDLE hMlme, TI_UINT16 status) 448{ 449 mlme_t *pHandle; 450 paramInfo_t param; 451 TI_STATUS fStatus; 452 453 pHandle = (mlme_t*)hMlme; 454 455 if (pHandle == NULL) 456 return TI_NOK; 457 458 if (pHandle->legacyAuthType == AUTH_LEGACY_NONE) 459 return TI_NOK; 460 461 pHandle->mlmeData.uStatusCode = status; 462 463 /* If status is successful */ 464 if (status == 0) 465 { 466 /* Mark a successful status - used for conn.c */ 467 pHandle->mlmeData.mgmtStatus = STATUS_SUCCESSFUL; 468 fStatus = mlme_smEvent(&pHandle->currentState, MLME_SM_EVENT_AUTH_SUCCESS, pHandle); 469 } 470 else 471 { 472 /* Now, if the MLME legacy auth type is AUTO_SWITCH, and the Auth legacy auth type is shared key, 473 we configure the auth SM to open system, otherwise, this is really an authentication failure. */ 474 param.paramType = AUTH_LEGACY_TYPE_PARAM; 475 auth_getParam(pHandle->hAuth, ¶m); 476 477 if ((pHandle->legacyAuthType == AUTH_LEGACY_AUTO_SWITCH) && (param.content.authLegacyAuthType == AUTH_LEGACY_SHARED_KEY)) 478 { 479 param.content.authLegacyAuthType = AUTH_LEGACY_OPEN_SYSTEM; 480 fStatus = auth_setParam(pHandle->hAuth, ¶m); 481 fStatus = auth_start(pHandle->hAuth); 482 } 483 484 else 485 { 486 pHandle->mlmeData.mgmtStatus = STATUS_AUTH_REJECT; 487 fStatus = mlme_smEvent(&pHandle->currentState, MLME_SM_EVENT_AUTH_FAIL, pHandle); 488 } 489 490 } 491 492 return fStatus; 493} 494 495/** 496* 497* mlme_reportAssocStatus - Set a specific parameter to the MLME SM 498* 499* \b Description: 500* 501* Set a specific parameter to the MLME SM. 502* 503* \b ARGS: 504* 505* I - hMlme - MLME SM context \n 506* I/O - pParam - Parameter \n 507* 508* \b RETURNS: 509* 510* TI_OK if successful, TI_NOK otherwise. 511* 512* \sa mlme_Start, mlme_Stop 513*/ 514TI_STATUS mlme_reportAssocStatus(TI_HANDLE hMlme, TI_UINT16 status) 515{ 516 mlme_t *pHandle; 517 TI_STATUS fStatus; 518 519 pHandle = (mlme_t*)hMlme; 520 521 if (pHandle == NULL) 522 return TI_NOK; 523 524 if (pHandle->legacyAuthType == AUTH_LEGACY_NONE) 525 return TI_NOK; 526 527 pHandle->mlmeData.uStatusCode = status; 528 529 /* If status is successful */ 530 if (status == 0) 531 { 532 pHandle->mlmeData.mgmtStatus = STATUS_SUCCESSFUL; 533 fStatus = mlme_smEvent(&pHandle->currentState, MLME_SM_EVENT_ASSOC_SUCCESS, pHandle); 534 } else 535 { 536 pHandle->mlmeData.mgmtStatus = STATUS_ASSOC_REJECT; 537 fStatus = mlme_smEvent(&pHandle->currentState, MLME_SM_EVENT_ASSOC_FAIL, pHandle); 538 } 539 540 return fStatus; 541} 542 543 544/** 545* 546* mlme_SetParam - Set a specific parameter to the MLME SM 547* 548* \b Description: 549* 550* Set a specific parameter to the MLME SM. 551* 552* \b ARGS: 553* 554* I - hMlme - MLME SM context \n 555* I/O - pParam - Parameter \n 556* 557* \b RETURNS: 558* 559* TI_OK if successful, TI_NOK otherwise. 560* 561* \sa mlme_Start, mlme_Stop 562*/ 563TI_STATUS mlme_smEvent(TI_UINT8 *currentState, TI_UINT8 event, TI_HANDLE hMlme) 564{ 565 mlme_t *pMlme = (mlme_t *)hMlme; 566 TI_STATUS status; 567 TI_UINT8 nextState; 568 569 status = fsm_GetNextState(pMlme->pMlmeSm, *currentState, event, &nextState); 570 if (status != TI_OK) 571 { 572 TRACE0(pMlme->hReport, REPORT_SEVERITY_ERROR, "MLME_SM: ERROR - failed getting next state \n"); 573 574 return(TI_NOK); 575 } 576 577 TRACE3( pMlme->hReport, REPORT_SEVERITY_INFORMATION, "mlme_smEvent: <currentState = %d, event = %d> --> nextState = %d\n", *currentState, event, nextState); 578 579 status = fsm_Event(pMlme->pMlmeSm, currentState, event, (void *)pMlme); 580 581 return(status); 582} 583 584/* state machine functions */ 585 586TI_STATUS mlme_smStartIdle(mlme_t *pMlme) 587{ 588 TI_STATUS status; 589 590 status = auth_start(pMlme->hAuth); 591 592 return status; 593} 594 595TI_STATUS mlme_smClass3Idle(mlme_t *pMlme) 596{ 597 return TI_OK; 598} 599 600 601 602TI_STATUS mlme_smAuthSuccessAuthWait(mlme_t *pMlme) 603{ 604 TI_STATUS status; 605 606 if (pMlme->reAssoc) 607 { 608 status = reassoc_start(pMlme->hAssoc); 609 } 610 else 611 { 612 status = assoc_start(pMlme->hAssoc); 613 } 614 615 return status; 616} 617 618TI_STATUS mlme_smAuthFailAuthWait(mlme_t *pMlme) 619{ 620 TI_STATUS status; 621 622 status = mlme_smReportStatus(pMlme); 623 624 return status; 625} 626 627TI_STATUS mlme_smStopAssocWait(mlme_t *pMlme) 628{ 629 mlme_stopAssocAndAuth(pMlme); 630 return TI_OK; 631} 632 633TI_STATUS mlme_smAssocSuccessAssocWait(mlme_t *pMlme) 634{ 635 TI_STATUS status; 636 637 status = mlme_smReportStatus(pMlme); 638 639 return status; 640} 641 642TI_STATUS mlme_smAssocFailAssocWait(mlme_t *pMlme) 643{ 644 TI_STATUS status; 645 646 status = mlme_smReportStatus(pMlme); 647 648 return status; 649} 650 651 652TI_STATUS mlme_smStopAssoc(mlme_t *pMlme) 653{ 654 mlme_stopAssocAndAuth(pMlme); 655 return TI_OK; 656} 657 658 659 660TI_STATUS mlme_smNOP(mlme_t *pMlme) 661{ 662 return TI_OK; 663} 664 665TI_STATUS mlme_smActionUnexpected(mlme_t *pMlme) 666{ 667 return TI_OK; 668} 669 670/* local functions */ 671 672TI_STATUS mlme_smReportStatus(mlme_t *pMlme) 673{ 674 TI_STATUS status; 675 676 if (pMlme == NULL) 677 { 678 return TI_NOK; 679 } 680 681 status = conn_reportMlmeStatus(pMlme->hConn, pMlme->mlmeData.mgmtStatus, pMlme->mlmeData.uStatusCode); 682 return status; 683} 684 685 686static void mlme_stopAssocAndAuth(mlme_t *pMlme) 687{ 688 689 TI_BOOL sendDeAuth; 690 TI_BOOL sendDisAssoc; 691 692 /* Don't send deauth/disassoc, FW will do it on disconnect command */ 693 sendDeAuth = TI_FALSE; 694 sendDisAssoc = TI_FALSE; 695 696 TRACE0(pMlme->hReport, REPORT_SEVERITY_INFORMATION, "mlme_stopAssocAndAuth: Auth/assoc stop without sending deauth/disassoc\n"); 697 698 assoc_setDisAssocFlag(pMlme->hAssoc, sendDisAssoc); 699 assoc_stop(pMlme->hAssoc); 700 701 auth_stop(pMlme->hAuth, sendDeAuth, pMlme->disConnReason ); 702} 703/***************************************************************************** 704** 705** MLME messages builder/Parser 706** 707*****************************************************************************/ 708 709 710 711 712 713 714 715