1 /**************************************************************************** 2 **+-----------------------------------------------------------------------+** 3 **| |** 4 **| Copyright(c) 1998 - 2008 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 ****************************************************************************/ 35 36 /** \file mainKeySM.c 37 * \brief Main key state machine implementation. 38 * 39 * \see mainKeySM.h 40 */ 41 42 #include "osApi.h" 43 44 #include "paramOut.h" 45 /*#include "paramIn.h"*/ 46 47 #include "utils.h" 48 #include "report.h" 49 50 #include "rsn.h" 51 #include "rsnApi.h" 52 #include "smeApi.h" 53 54 #include "mainSecSm.h" 55 #include "keyParser.h" 56 #include "broadcastKeySM.h" 57 #include "unicastKeySM.h" 58 59 #include "mainKeysSm.h" 60 #include "mainKeysSmInternal.h" 61 #include "DataCtrl_Api.h" 62 #include "admCtrl.h" 63 #include "EvHandler.h" 64 #include "TI_IPC_Api.h" 65 66 67 68 static TI_STATUS mainKeys_smEvent(struct _mainKeys_t *pMainKeys, UINT8 event, void* pData); 69 70 /** 71 * 72 * mainKeys_create 73 * 74 * \b Description: 75 * 76 * Allocate memory for the main security context, and create all the rest of the needed contexts. 77 * 78 * \b ARGS: 79 * 80 * I - hOs - OS handle for OS operations. 81 * 82 * \b RETURNS: 83 * 84 * pointer to main security context. If failed, returns NULL. 85 * 86 * \sa 87 */ 88 mainKeys_t* mainKeys_create(TI_HANDLE hOs) 89 { 90 mainKeys_t *pHandle; 91 TI_STATUS status; 92 93 /* allocate association context memory */ 94 pHandle = (mainKeys_t*)os_memoryAlloc(hOs, sizeof(mainKeys_t)); 95 if (pHandle == NULL) 96 { 97 return NULL; 98 } 99 100 os_memoryZero(hOs, pHandle, sizeof(mainKeys_t)); 101 102 /* allocate memory for association state machine */ 103 status = fsm_Create(hOs, &pHandle->pMainKeysSm, MAIN_KEYS_NUM_STATES, MAIN_KEYS_NUM_EVENTS); 104 if (status != OK) 105 { 106 os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); 107 return NULL; 108 } 109 110 pHandle->timer = os_timerCreate(hOs, mainKeys_sessionTimeout, pHandle); 111 if (pHandle->timer == NULL) 112 { 113 fsm_Unload(hOs, pHandle->pMainKeysSm); 114 os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); 115 return NULL; 116 } 117 118 pHandle->pKeyParser = keyParser_create(hOs); 119 if (pHandle->pKeyParser == NULL) 120 { 121 os_timerDestroy(hOs, pHandle->timer); 122 fsm_Unload(hOs, pHandle->pMainKeysSm); 123 os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); 124 return NULL; 125 } 126 127 pHandle->pBcastSm = broadcastKey_create(hOs); 128 if (pHandle->pBcastSm == NULL) 129 { 130 keyParser_unload(pHandle->pKeyParser); 131 os_timerDestroy(hOs, pHandle->timer); 132 fsm_Unload(hOs, pHandle->pMainKeysSm); 133 os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); 134 return NULL; 135 } 136 137 pHandle->pUcastSm = unicastKey_create(hOs); 138 if (pHandle->pBcastSm == NULL) 139 { 140 broadcastKey_unload(pHandle->pBcastSm); 141 keyParser_unload(pHandle->pKeyParser); 142 os_timerDestroy(hOs, pHandle->timer); 143 fsm_Unload(hOs, pHandle->pMainKeysSm); 144 os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); 145 return NULL; 146 } 147 148 pHandle->hOs = hOs; 149 150 /* At first Timeout we will send MediaSpecific Event */ 151 /* At any other Timeout we will send the Timeout Event */ 152 153 pHandle->mainKeysTimeoutCounter = FALSE; 154 155 return pHandle; 156 } 157 158 /** 159 * 160 * mainKeys_config 161 * 162 * \b Description: 163 * 164 * Init main security state machine state machine 165 * 166 * \b ARGS: 167 * 168 * none 169 * 170 * \b RETURNS: 171 * 172 * OK on success, NOK otherwise. 173 * 174 * \sa 175 */ 176 TI_STATUS mainKeys_config(mainKeys_t *pMainKeys, 177 rsn_paeConfig_t *pPaeConfig, 178 void *pParent, 179 TI_HANDLE hReport, 180 TI_HANDLE hOs, 181 TI_HANDLE hCtrlData, 182 TI_HANDLE hEvHandler, 183 TI_HANDLE hConn, 184 TI_HANDLE hRsn ) 185 186 { 187 TI_STATUS status; 188 189 /** Main key State Machine matrix */ 190 fsm_actionCell_t mainKeysSM_matrix[MAIN_KEYS_NUM_STATES][MAIN_KEYS_NUM_EVENTS] = 191 { 192 /* next state and actions for IDLE state */ 193 { {MAIN_KEYS_STATE_START, (fsm_Action_t)mainKeys_startIdle}, 194 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmNop}, 195 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmUnexpected}, 196 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmUnexpected}, 197 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmUnexpected} 198 }, 199 200 /* next state and actions for START state */ 201 { {MAIN_KEYS_STATE_START, (fsm_Action_t)mainKeySmUnexpected}, 202 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopStart}, 203 {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, 204 {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, 205 {MAIN_KEYS_STATE_START, (fsm_Action_t)mainKeys_smTimeOut} 206 }, 207 208 /* next state and actions for UNICAST COMPLETE state */ 209 { {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeySmUnexpected}, 210 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopUcastComplete}, 211 {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, 212 {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeys_bcastCompleteUcastComplete}, 213 {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeys_smTimeOut} 214 }, 215 216 /* next state and actions for BROADCAST COMPLETE state */ 217 { {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeySmUnexpected}, 218 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopBcastComplete}, 219 {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeys_ucastCompleteBcastComplete}, 220 {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, 221 {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeys_smTimeOut} 222 }, 223 224 /* next state and actions for COMPLETE state */ 225 { {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmUnexpected}, 226 {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopComplete}, 227 {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmNop}, 228 {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmNop}, 229 {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmUnexpected} 230 } 231 }; 232 233 pMainKeys->hCtrlData = hCtrlData; 234 pMainKeys->hOs = hOs; 235 pMainKeys->hReport = hReport; 236 pMainKeys->hEvHandler = hEvHandler; 237 pMainKeys->hConn = hConn; 238 pMainKeys->hRsn = hRsn; 239 240 pMainKeys->pParent = pParent; 241 pMainKeys->keysTimeout = MAIN_KEYS_TIMEOUT; 242 243 pMainKeys->start = mainKeys_start; 244 pMainKeys->stop = mainKeys_stop; 245 pMainKeys->reportUcastStatus = mainKeys_reportUcastStatus; 246 pMainKeys->reportBcastStatus = mainKeys_reportBcastStatus; 247 pMainKeys->setKey = mainKeys_setKey; 248 pMainKeys->removeKey = mainKeys_removeKey; 249 pMainKeys->setDefaultKeyId = mainKeys_setDefaultKeyId; 250 pMainKeys->getSessionKey = mainKeys_getSessionKey; 251 252 pMainKeys->currentState = MAIN_KEYS_STATE_IDLE; 253 254 status = fsm_Config(pMainKeys->pMainKeysSm, &mainKeysSM_matrix[0][0], 255 MAIN_KEYS_NUM_STATES, MAIN_KEYS_NUM_EVENTS, NULL, pMainKeys->hOs); 256 if (status != OK) 257 { 258 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 259 ("MAIN_KEYS_SM: Error in configuring SM\n")); 260 return status; 261 } 262 263 status = keyParser_config(pMainKeys->pKeyParser, 264 pPaeConfig, 265 pMainKeys->pUcastSm, 266 pMainKeys->pBcastSm, 267 pMainKeys, 268 hReport, 269 hOs, 270 hCtrlData); 271 if (status != OK) 272 { 273 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 274 ("MAIN_KEYS_SM: Error in configuring key parser\n")); 275 return status; 276 } 277 278 status = broadcastKey_config(pMainKeys->pBcastSm, pPaeConfig, pMainKeys, hReport, hOs); 279 if (status != OK) 280 { 281 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 282 ("MAIN_KEYS_SM: Error in configuring broadcast key SM\n")); 283 return status; 284 } 285 286 status = unicastKey_config(pMainKeys->pUcastSm, pPaeConfig, pMainKeys, hReport, hOs); 287 if (status != OK) 288 { 289 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 290 ("MAIN_KEYS_SM: Error in configuring unicast key SM\n")); 291 return status; 292 } 293 294 return OK; 295 } 296 297 /** 298 * 299 * mainKeys_config 300 * 301 * \b Description: 302 * 303 * Init main security state machine state machine 304 * 305 * \b ARGS: 306 * 307 * none 308 * 309 * \b RETURNS: 310 * 311 * OK on success, NOK otherwise. 312 * 313 * \sa 314 */ 315 TI_STATUS mainKeys_unload(mainKeys_t *pMainKeys) 316 { 317 TI_STATUS status; 318 319 if (pMainKeys == NULL) 320 { 321 return NOK; 322 } 323 324 status = fsm_Unload(pMainKeys->hOs, pMainKeys->pMainKeysSm); 325 if (status != OK) 326 { 327 /* report failure but don't stop... */ 328 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 329 ("MAIN_KEYS_SM: Error releasing FSM memory \n")); 330 } 331 332 os_timerStop(pMainKeys->hOs, pMainKeys->timer); 333 os_timerDestroy(pMainKeys->hOs, pMainKeys->timer); 334 335 status = keyParser_unload(pMainKeys->pKeyParser); 336 if (status != OK) 337 { 338 /* report failure but don't stop... */ 339 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 340 ("MAIN_KEYS_SM: Error unloading key parser\n")); 341 } 342 343 status = broadcastKey_unload(pMainKeys->pBcastSm); 344 if (status != OK) 345 { 346 /* report failure but don't stop... */ 347 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 348 ("MAIN_KEYS_SM: Error unloading broadcast key SM\n")); 349 } 350 351 status = unicastKey_unload(pMainKeys->pUcastSm); 352 if (status != OK) 353 { 354 /* report failure but don't stop... */ 355 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 356 ("MAIN_KEYS_SM: Error unloading unicast key SM\n")); 357 } 358 359 os_memoryFree(pMainKeys->hOs, pMainKeys, sizeof(mainKeys_t)); 360 361 return OK; 362 } 363 364 365 /** 366 * 367 * rsn_mainKeySmStart 368 * 369 * \b Description: 370 * 371 * START event handler 372 * 373 * \b ARGS: 374 * 375 * I - pCtrlB - station control block \n 376 * 377 * \b RETURNS: 378 * 379 * OK on success, NOK otherwise. 380 * 381 * \sa rsn_mainKeySmStop() 382 */ 383 384 TI_STATUS mainKeys_start(struct _mainKeys_t *pMainKeys) 385 { 386 TI_STATUS status; 387 388 status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_START, pMainKeys); 389 390 return status; 391 } 392 393 /** 394 * 395 * rsn_mainKeySmStop 396 * 397 * \b Description: 398 * 399 * STOP event handler 400 * 401 * \b ARGS: 402 * 403 * I - pCtrlB - station control block \n 404 * 405 * \b RETURNS: 406 * 407 * OK on success, NOK otherwise. 408 * 409 * \sa rsn_mainKeySmStart() 410 */ 411 412 TI_STATUS mainKeys_stop(struct _mainKeys_t *pMainKeys) 413 { 414 TI_STATUS status; 415 416 status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_STOP, pMainKeys); 417 418 return status; 419 } 420 421 /** 422 * 423 * rsn_mainKeySmReportUnicastComplete 424 * 425 * \b Description: 426 * 427 * UNICAST_COMPLETE event handler 428 * 429 * \b ARGS: 430 * 431 * I - pCtrlB - station control block \n 432 * 433 * \b RETURNS: 434 * 435 * OK on success, NOK otherwise. 436 * 437 * \sa rsn_mainKeySmReportBroadcastComplete() 438 */ 439 440 TI_STATUS mainKeys_reportUcastStatus(struct _mainKeys_t *pMainKeys, TI_STATUS ucastStatus) 441 { 442 TI_STATUS status=NOK; 443 paramInfo_t param; 444 externalAuthMode_e extAuthMode; 445 446 if (ucastStatus == OK) 447 { 448 449 param.content.txDataCurrentPrivacyInvokedMode = TRUE; 450 param.paramType = TX_DATA_CURRENT_PRIVACY_INVOKE_MODE_PARAM; 451 txData_setParam(pMainKeys->pParent->pParent->hTx, ¶m); 452 status = pMainKeys->pParent->pParent->pAdmCtrl->getExtAuthMode(pMainKeys->pParent->pParent->pAdmCtrl, &extAuthMode); 453 if (status != OK) 454 { 455 return status; 456 } 457 if (extAuthMode >= RSN_EXT_AUTH_MODE_WPA) 458 { 459 param.content.txDataEapolEncryptionStatus = TRUE; 460 } 461 else 462 { 463 param.content.txDataEapolEncryptionStatus = FALSE; 464 } 465 param.paramType = TX_DATA_EAPOL_ENCRYPTION_STATUS_PARAM; 466 txData_setParam(pMainKeys->pParent->pParent->hTx, ¶m); 467 468 status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_UCAST_COMPLETE, pMainKeys); 469 } 470 471 return status; 472 } 473 474 475 /** 476 * 477 * rsn_mainKeySmReportBroadcastComplete 478 * 479 * \b Description: 480 * 481 * BROADCAST_COMPLETE event handler 482 * 483 * \b ARGS: 484 * 485 * I - pCtrlB - station control block \n 486 * 487 * \b RETURNS: 488 * 489 * OK on success, NOK otherwise. 490 * 491 * \sa rsn_mainKeySmReportUnicastComplete() 492 */ 493 494 TI_STATUS mainKeys_reportBcastStatus(struct _mainKeys_t *pMainKeys, TI_STATUS bcastStatus) 495 { 496 TI_STATUS status=NOK; 497 498 if (bcastStatus == OK) 499 { 500 status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_BCAST_COMPLETE, pMainKeys); 501 } 502 503 return status; 504 } 505 506 /** 507 * 508 * mainKeySmSessionTimeout 509 * 510 * \b Description: 511 * 512 * SESSION_TIMEOUOT event handler 513 * 514 * \b ARGS: 515 * 516 * I - pData - station control block \n 517 * 518 * \b RETURNS: 519 * 520 * OK on success, NOK otherwise. 521 */ 522 TI_STATUS mainKeys_setKey(struct _mainKeys_t *pMainKeys, securityKeys_t *pKey) 523 { 524 return (pMainKeys->pParent->setKey(pMainKeys->pParent, pKey)); 525 } 526 527 /** 528 * 529 * mainKeySmSessionTimeout 530 * 531 * \b Description: 532 * 533 * SESSION_TIMEOUOT event handler 534 * 535 * \b ARGS: 536 * 537 * I - pData - station control block \n 538 * 539 * \b RETURNS: 540 * 541 * OK on success, NOK otherwise. 542 */ 543 TI_STATUS mainKeys_removeKey(struct _mainKeys_t *pMainKeys, securityKeys_t *pKey) 544 { 545 return (pMainKeys->pParent->removeKey(pMainKeys->pParent, pKey)); 546 } 547 548 /** 549 * 550 * mainKeySmSessionTimeout 551 * 552 * \b Description: 553 * 554 * SESSION_TIMEOUOT event handler 555 * 556 * \b ARGS: 557 * 558 * I - pData - station control block \n 559 * 560 * \b RETURNS: 561 * 562 * OK on success, NOK otherwise. 563 */ 564 TI_STATUS mainKeys_setDefaultKeyId(struct _mainKeys_t *pMainKeys, UINT8 keyId) 565 { 566 return (pMainKeys->pParent->setDefaultKeyId(pMainKeys->pParent, keyId)); 567 } 568 569 /** 570 * 571 * mainKeySmSessionTimeout 572 * 573 * \b Description: 574 * 575 * SESSION_TIMEOUOT event handler 576 * 577 * \b ARGS: 578 * 579 * I - pData - station control block \n 580 * 581 * \b RETURNS: 582 * 583 * OK on success, NOK otherwise. 584 */ 585 TI_STATUS mainKeys_getSessionKey(struct _mainKeys_t *pMainKeys, UINT8 *pKey, UINT32 *pKeyLen) 586 { 587 TI_STATUS status; 588 589 status = pMainKeys->pParent->getSessionKey(pMainKeys->pParent, pKey, pKeyLen); 590 591 return status; 592 } 593 594 /** 595 * 596 * mainKeySmSessionTimeout 597 * 598 * \b Description: 599 * 600 * SESSION_TIMEOUOT event handler 601 * 602 * \b ARGS: 603 * 604 * I - pData - station control block \n 605 * 606 * \b RETURNS: 607 * 608 * OK on success, NOK otherwise. 609 */ 610 611 void mainKeys_sessionTimeout(void *pMainKeys) 612 { 613 614 mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_SESSION_TIMEOUOT, pMainKeys); 615 616 } 617 618 619 #ifdef REPORT_LOG 620 621 static char *mainKeys_smStateDesc[MAIN_KEYS_NUM_STATES] = { 622 "STATE_IDLE", 623 "STATE_START", 624 "STATE_UNICAST_COMPLETE", 625 "STATE_BROADCAST_COMPLETE", 626 "STATE_COMPLETE", 627 }; 628 629 static char *mainKeys_smEventDesc[MAIN_KEYS_NUM_EVENTS] = { 630 "EVENT_START", 631 "EVENT_STOP", 632 "EVENT_UNICAST_COMPLETE", 633 "EVENT_BROADCAST_COMPLETE", 634 "EVENT_SESSION_TIMEOUOT" 635 }; 636 637 #endif 638 639 static TI_STATUS mainKeys_smEvent(struct _mainKeys_t *pMainKeys, UINT8 event, void* pData) 640 { 641 TI_STATUS status; 642 UINT8 nextState; 643 644 645 status = fsm_GetNextState(pMainKeys->pMainKeysSm, pMainKeys->currentState, event, &nextState); 646 if (status != OK) 647 { 648 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 649 ("MAIN_KEYS_SM: ERROR - failed getting next state \n")); 650 651 return(NOK); 652 } 653 654 WLAN_REPORT_SM(pMainKeys->hReport, RSN_MODULE_LOG, 655 ("MAIN_KEYS_SM: <%s, %s> --> %s\n", 656 mainKeys_smStateDesc[pMainKeys->currentState], 657 mainKeys_smEventDesc[event], 658 mainKeys_smStateDesc[nextState])); 659 660 status = fsm_Event(pMainKeys->pMainKeysSm, &pMainKeys->currentState, event, pData); 661 662 return status; 663 } 664 /** 665 * 666 * mainKeySmStartSubKeySmsAndTimer 667 * 668 * \b Description: 669 * 670 * Starts unicast & broadcast key SMs and session timer. 671 * 672 * \b ARGS: 673 * 674 * I - pData - station control block \n 675 * 676 * \b RETURNS: 677 * 678 * OK on success, NOK otherwise. 679 */ 680 681 TI_STATUS mainKeys_startIdle(struct _mainKeys_t *pMainKeys) 682 { 683 TI_STATUS status; 684 685 status = pMainKeys->pUcastSm->start(pMainKeys->pUcastSm); 686 if (status != OK) 687 { 688 return NOK; 689 } 690 691 status = pMainKeys->pBcastSm->start(pMainKeys->pBcastSm); 692 if (status != OK) 693 { 694 return NOK; 695 } 696 697 os_timerStart(pMainKeys->hOs, pMainKeys->timer, pMainKeys->keysTimeout, FALSE); 698 699 status = pMainKeys->pKeyParser->replayReset(pMainKeys->pKeyParser); 700 701 return status; 702 } 703 704 705 /** 706 * 707 * mainKeySmStopSubKeySmsAndTimer 708 * 709 * \b Description: 710 * 711 * Stops unicast & broadcast key SMs and session timer. 712 * 713 * \b ARGS: 714 * 715 * I - pData - station control block \n 716 * 717 * \b RETURNS: 718 * 719 * OK on success, NOK otherwise. 720 */ 721 TI_STATUS mainKeys_stopStart(struct _mainKeys_t *pMainKeys) 722 { 723 TI_STATUS status = OK; 724 725 status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); 726 if (status != OK) 727 { 728 return NOK; 729 } 730 731 status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); 732 if (status != OK) 733 { 734 return NOK; 735 } 736 737 os_timerStop(pMainKeys->hOs, pMainKeys->timer); 738 739 return status; 740 } 741 742 743 /** 744 * 745 * mainKeySmStopSubKeySmsAndTimer 746 * 747 * \b Description: 748 * 749 * Stops unicast & broadcast key SMs and session timer. 750 * 751 * \b ARGS: 752 * 753 * I - pData - station control block \n 754 * 755 * \b RETURNS: 756 * 757 * OK on success, NOK otherwise. 758 */ 759 TI_STATUS mainKeys_stopUcastComplete(struct _mainKeys_t *pMainKeys) 760 { 761 TI_STATUS status = OK; 762 763 status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); 764 if (status != OK) 765 { 766 return NOK; 767 } 768 769 status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); 770 if (status != OK) 771 { 772 return NOK; 773 } 774 775 os_timerStop(pMainKeys->hOs, pMainKeys->timer); 776 777 return status; 778 } 779 780 /** 781 * 782 * mainKeySmReportComplete 783 * 784 * \b Description: 785 * 786 * Report key complete to the main security SM. 787 * 788 * \b ARGS: 789 * 790 * I - pData - station control block \n 791 * 792 * \b RETURNS: 793 * 794 * OK on success, NOK otherwise. 795 */ 796 TI_STATUS mainKeys_bcastCompleteUcastComplete(struct _mainKeys_t *pMainKeys) 797 { 798 TI_STATUS status; 799 800 WLAN_REPORT_INFORMATION(pMainKeys->hReport, RSN_MODULE_LOG, 801 ("mainKeys_bcastCompleteUcastComplete - sending Interrogate \n")); 802 os_timerStop(pMainKeys->hOs, pMainKeys->timer); 803 804 status = pMainKeys->pParent->reportKeysStatus(pMainKeys->pParent, OK); 805 806 return status; 807 } 808 809 810 /** 811 * 812 * mainKeySmStopSubKeySmsAndTimer 813 * 814 * \b Description: 815 * 816 * Stops unicast & broadcast key SMs and session timer. 817 * 818 * \b ARGS: 819 * 820 * I - pData - station control block \n 821 * 822 * \b RETURNS: 823 * 824 * OK on success, NOK otherwise. 825 */ 826 TI_STATUS mainKeys_stopBcastComplete(struct _mainKeys_t *pMainKeys) 827 { 828 TI_STATUS status = OK; 829 830 status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); 831 if (status != OK) 832 { 833 return NOK; 834 } 835 836 status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); 837 if (status != OK) 838 { 839 return NOK; 840 } 841 842 os_timerStop(pMainKeys->hOs, pMainKeys->timer); 843 844 return status; 845 } 846 847 /** 848 * 849 * mainKeySmReportComplete 850 * 851 * \b Description: 852 * 853 * Report key complete to the main security SM. 854 * 855 * \b ARGS: 856 * 857 * I - pData - station control block \n 858 * 859 * \b RETURNS: 860 * 861 * OK on success, NOK otherwise. 862 */ 863 TI_STATUS mainKeys_ucastCompleteBcastComplete(struct _mainKeys_t *pMainKeys) 864 { 865 TI_STATUS status; 866 867 WLAN_REPORT_INFORMATION(pMainKeys->hReport, RSN_MODULE_LOG, 868 ("mainKeys_ucastCompleteBcastComplete \n")); 869 870 os_timerStop(pMainKeys->hOs, pMainKeys->timer); 871 872 status = pMainKeys->pParent->reportKeysStatus(pMainKeys->pParent, OK); 873 874 return status; 875 } 876 877 /** 878 * 879 * mainKeySmStopSubKeySmsAndTimer 880 * 881 * \b Description: 882 * 883 * Stops unicast & broadcast key SMs and session timer. 884 * 885 * \b ARGS: 886 * 887 * I - pData - station control block \n 888 * 889 * \b RETURNS: 890 * 891 * OK on success, NOK otherwise. 892 */ 893 TI_STATUS mainKeys_stopComplete(struct _mainKeys_t *pMainKeys) 894 { 895 TI_STATUS status = OK; 896 897 status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); 898 if (status != OK) 899 { 900 return NOK; 901 } 902 903 status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); 904 if (status != OK) 905 { 906 return NOK; 907 } 908 909 return status; 910 } 911 912 /** 913 * 914 * mainKeySmLogMessage 915 * 916 * \b Description: 917 * 918 * Prints Log messge.\n 919 * Start session timer. 920 * 921 * \b ARGS: 922 * 923 * I - pData - station control block \n 924 * 925 * \b RETURNS: 926 * 927 * OK on success, NOK otherwise. 928 */ 929 TI_STATUS mainKeys_smTimeOut(void* data) 930 { 931 OS_802_11_AUTHENTICATION_REQUEST *request; 932 UINT8 AuthBuf[sizeof(UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)]; 933 paramInfo_t param; 934 TI_STATUS status; 935 struct _mainKeys_t *pMainKeys = (struct _mainKeys_t *)data; 936 937 938 WLAN_REPORT_INFORMATION(pMainKeys->hReport, RSN_MODULE_LOG, 939 ("MAIN_KEY_SM: TRAP: Session Timeout for station , mainKeysTimeoutCounter=%d\n", 940 pMainKeys->mainKeysTimeoutCounter)); 941 942 request = (OS_802_11_AUTHENTICATION_REQUEST *)(AuthBuf + sizeof(UINT32)); 943 request->Length = sizeof(OS_802_11_AUTHENTICATION_REQUEST); 944 945 param.paramType = CTRL_DATA_CURRENT_BSSID_PARAM; 946 status = ctrlData_getParam(pMainKeys->hCtrlData, ¶m); 947 if (status != OK) 948 { 949 return NOK; 950 } 951 952 WLAN_REPORT_INFORMATION(pMainKeys->hReport, RSN_MODULE_LOG, 953 ("current station is banned from the roaming candidates list for %d Ms\n", 954 RSN_MAIN_KEYS_SESSION_TIMEOUT)); 955 956 rsn_banSite(pMainKeys->hRsn, param.content.ctrlDataCurrentBSSID, RSN_SITE_BAN_LEVEL_FULL, RSN_MAIN_KEYS_SESSION_TIMEOUT); 957 958 959 /* mainKeysTimeoutCounter is a boolean variable, With states: */ 960 /* TRUE - It is a Timeout Association Event */ 961 /* FALSE - It is a Media specific Event */ 962 963 if (!pMainKeys->mainKeysTimeoutCounter) 964 { 965 /* Fill Media specific indication fields and send to OS/User */ 966 os_memoryCopy(pMainKeys->hOs, request->BSSID, (void *)param.content.ctrlDataCurrentBSSID.addr, MAC_ADDR_LEN); 967 968 request->Flags = OS_802_11_REQUEST_REAUTH; 969 970 *(UINT32*)AuthBuf = os802_11StatusType_Authentication; 971 972 WLAN_REPORT_INFORMATION(pMainKeys->hReport, RSN_MODULE_LOG, 973 (" %d Ms\n",RSN_MAIN_KEYS_SESSION_TIMEOUT)); 974 975 EvHandlerSendEvent(pMainKeys->hEvHandler, IPC_EVENT_MEDIA_SPECIFIC, (UINT8*)AuthBuf, 976 sizeof(UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)); 977 978 os_timerStart(pMainKeys->hOs, pMainKeys->timer, pMainKeys->keysTimeout, FALSE); 979 pMainKeys->mainKeysTimeoutCounter = TRUE; 980 } 981 else 982 { 983 pMainKeys->mainKeysTimeoutCounter = FALSE; 984 rsn_reportAuthFailure(pMainKeys->hRsn, RSN_AUTH_STATUS_TIMEOUT); 985 conn_reportRsnStatus(pMainKeys->hConn, (mgmtStatus_e)STATUS_SECURITY_FAILURE); 986 } 987 return OK; 988 } 989 990 991 TI_STATUS mainKeySmUnexpected(struct _mainKeys_t *pMainKeys) 992 { 993 WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG, 994 ("MAIN_KEY_SM: ERROR UnExpected Event\n")); 995 996 return(OK); 997 } 998 999 TI_STATUS mainKeySmNop(struct _mainKeys_t *pMainKeys) 1000 { 1001 return(OK); 1002 } 1003 1004