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