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 */ 82 static 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 */ 107 TI_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 */ 154 TI_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 */ 186 void 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 263 void 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 271 TI_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 324 TI_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 */ 370 TI_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 */ 409 TI_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 */ 447 TI_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 */ 514 TI_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 */ 563 TI_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 586 TI_STATUS mlme_smStartIdle(mlme_t *pMlme) 587 { 588 TI_STATUS status; 589 590 status = auth_start(pMlme->hAuth); 591 592 return status; 593 } 594 595 TI_STATUS mlme_smClass3Idle(mlme_t *pMlme) 596 { 597 return TI_OK; 598 } 599 600 601 602 TI_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 618 TI_STATUS mlme_smAuthFailAuthWait(mlme_t *pMlme) 619 { 620 TI_STATUS status; 621 622 status = mlme_smReportStatus(pMlme); 623 624 return status; 625 } 626 627 TI_STATUS mlme_smStopAssocWait(mlme_t *pMlme) 628 { 629 mlme_stopAssocAndAuth(pMlme); 630 return TI_OK; 631 } 632 633 TI_STATUS mlme_smAssocSuccessAssocWait(mlme_t *pMlme) 634 { 635 TI_STATUS status; 636 637 status = mlme_smReportStatus(pMlme); 638 639 return status; 640 } 641 642 TI_STATUS mlme_smAssocFailAssocWait(mlme_t *pMlme) 643 { 644 TI_STATUS status; 645 646 status = mlme_smReportStatus(pMlme); 647 648 return status; 649 } 650 651 652 TI_STATUS mlme_smStopAssoc(mlme_t *pMlme) 653 { 654 mlme_stopAssocAndAuth(pMlme); 655 return TI_OK; 656 } 657 658 659 660 TI_STATUS mlme_smNOP(mlme_t *pMlme) 661 { 662 return TI_OK; 663 } 664 665 TI_STATUS mlme_smActionUnexpected(mlme_t *pMlme) 666 { 667 return TI_OK; 668 } 669 670 /* local functions */ 671 672 TI_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 686 static 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
