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 */
mlme_create(TI_HANDLE hOs)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 */
mlme_unload(TI_HANDLE hMlme)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 */
mlme_init(TStadHandlesList * pStadHandles)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
mlme_SetDefaults(TI_HANDLE hMlmeSm,TMlmeInitParams * pMlmeInitParams)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
mlme_setParam(TI_HANDLE hMlmeSm,paramInfo_t * pParam)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
mlme_getParam(TI_HANDLE hMlmeSm,paramInfo_t * pParam)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 */
mlme_start(TI_HANDLE hMlme)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 */
mlme_stop(TI_HANDLE hMlme,DisconnectType_e disConnType,mgmtStatus_e reason)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 */
mlme_reportAuthStatus(TI_HANDLE hMlme,TI_UINT16 status)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 */
mlme_reportAssocStatus(TI_HANDLE hMlme,TI_UINT16 status)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 */
mlme_smEvent(TI_UINT8 * currentState,TI_UINT8 event,TI_HANDLE hMlme)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
mlme_smStartIdle(mlme_t * pMlme)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
mlme_smClass3Idle(mlme_t * pMlme)595 TI_STATUS mlme_smClass3Idle(mlme_t *pMlme)
596 {
597 return TI_OK;
598 }
599
600
601
mlme_smAuthSuccessAuthWait(mlme_t * pMlme)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
mlme_smAuthFailAuthWait(mlme_t * pMlme)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
mlme_smStopAssocWait(mlme_t * pMlme)627 TI_STATUS mlme_smStopAssocWait(mlme_t *pMlme)
628 {
629 mlme_stopAssocAndAuth(pMlme);
630 return TI_OK;
631 }
632
mlme_smAssocSuccessAssocWait(mlme_t * pMlme)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
mlme_smAssocFailAssocWait(mlme_t * pMlme)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
mlme_smStopAssoc(mlme_t * pMlme)652 TI_STATUS mlme_smStopAssoc(mlme_t *pMlme)
653 {
654 mlme_stopAssocAndAuth(pMlme);
655 return TI_OK;
656 }
657
658
659
mlme_smNOP(mlme_t * pMlme)660 TI_STATUS mlme_smNOP(mlme_t *pMlme)
661 {
662 return TI_OK;
663 }
664
mlme_smActionUnexpected(mlme_t * pMlme)665 TI_STATUS mlme_smActionUnexpected(mlme_t *pMlme)
666 {
667 return TI_OK;
668 }
669
670 /* local functions */
671
mlme_smReportStatus(mlme_t * pMlme)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
mlme_stopAssocAndAuth(mlme_t * pMlme)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