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 */
mainKeys_create(TI_HANDLE hOs)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 */
mainKeys_config(mainKeys_t * pMainKeys,TRsnPaeConfig * pPaeConfig,void * pParent,TI_HANDLE hReport,TI_HANDLE hOs,TI_HANDLE hCtrlData,TI_HANDLE hEvHandler,TI_HANDLE hConn,TI_HANDLE hRsn,TI_HANDLE hTimer)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 */
mainKeys_unload(mainKeys_t * pMainKeys)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
mainKeys_start(struct _mainKeys_t * pMainKeys)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
mainKeys_stop(struct _mainKeys_t * pMainKeys)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
mainKeys_reportUcastStatus(struct _mainKeys_t * pMainKeys,TI_STATUS ucastStatus)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
mainKeys_reportBcastStatus(struct _mainKeys_t * pMainKeys,TI_STATUS bcastStatus)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 */
mainKeys_setKey(struct _mainKeys_t * pMainKeys,TSecurityKeys * pKey)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 */
mainKeys_removeKey(struct _mainKeys_t * pMainKeys,TSecurityKeys * pKey)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 */
mainKeys_setDefaultKeyId(struct _mainKeys_t * pMainKeys,TI_UINT8 keyId)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 */
mainKeys_getSessionKey(struct _mainKeys_t * pMainKeys,TI_UINT8 * pKey,TI_UINT32 * pKeyLen)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
mainKeys_sessionTimeout(void * pMainKeys,TI_BOOL bTwdInitOccured)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
mainKeys_smEvent(struct _mainKeys_t * pMainKeys,TI_UINT8 event,void * pData)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
mainKeys_startIdle(struct _mainKeys_t * pMainKeys)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 */
mainKeys_stopStart(struct _mainKeys_t * pMainKeys)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 */
mainKeys_stopUcastComplete(struct _mainKeys_t * pMainKeys)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 */
mainKeys_bcastCompleteUcastComplete(struct _mainKeys_t * pMainKeys)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 */
mainKeys_stopBcastComplete(struct _mainKeys_t * pMainKeys)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 */
mainKeys_ucastCompleteBcastComplete(struct _mainKeys_t * pMainKeys)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 */
mainKeys_stopComplete(struct _mainKeys_t * pMainKeys)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 */
mainKeys_smTimeOut(void * data)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
mainKeySmUnexpected(struct _mainKeys_t * pMainKeys)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
mainKeySmNop(struct _mainKeys_t * pMainKeys)970 TI_STATUS mainKeySmNop(struct _mainKeys_t *pMainKeys)
971 {
972 return(TI_OK);
973 }
974
mainKeys_reAuth(TI_HANDLE pHandle)975 void mainKeys_reAuth(TI_HANDLE pHandle)
976 {
977 mainKeys_t *pMainKeys = (mainKeys_t *)pHandle;
978
979 rsn_reAuth(pMainKeys->hRsn);
980 }
981