/** @file keyMgmtsta_rom.c
 *
 *  @brief This file defines key management function for sta
 *
 * Copyright (C) 2014-2017, Marvell International Ltd.
 *
 * This software file (the "File") is distributed by Marvell International
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
 * (the "License").  You may use, redistribute and/or modify this File in
 * accordance with the terms and conditions of the License, a copy of which
 * is available by writing to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 * this warranty disclaimer.
 */

/******************************************************
Change log:
    03/07/2014: Initial version
******************************************************/
#include "wltypes.h"
#include "IEEE_types.h"
#include "hostsa_ext_def.h"
#include "authenticator.h"

#include "keyMgmtSta_rom.h"
#include "pmkCache_rom.h"
#include "crypt_new_rom.h"
#include "rc4_rom.h"
#include "aes_cmac_rom.h"
#include "sha1.h"
#include "md5.h"
#include "mrvl_sha256_crypto.h"
#include "wl_macros.h"

#define MIC_ERROR_QUIET_TIME_INTERVAL           60000000	/* 60 sec */
#define MIC_ERROR_CHECK_TIME_INTERVAL         60000000

void
supplicantSetAssocRsn_internal(phostsa_private priv, RSNConfig_t *pRsnConfig,
			       SecurityParams_t *pSecurityParams,
			       SecurityMode_t wpaType,
			       Cipher_t *pMcstCipher,
			       Cipher_t *pUcstCipher,
			       AkmSuite_t *pAkm,
			       IEEEtypes_RSNCapability_t *pRsnCap,
			       Cipher_t *pGrpMgmtCipher)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	memset(util_fns, &pRsnConfig->wpaType,
	       0x00, sizeof(pRsnConfig->wpaType));
	memset(util_fns, &pRsnConfig->ucstCipher,
	       0x00, sizeof(pRsnConfig->ucstCipher));
	memset(util_fns, &pRsnConfig->mcstCipher,
	       0x00, sizeof(pRsnConfig->mcstCipher));

	pRsnConfig->pmkidValid = 0;
	pRsnConfig->rsnCapValid = 0;
	pRsnConfig->grpMgmtCipherValid = 0;
	pRsnConfig->rsvd = 0;

	if (pSecurityParams->wpaType.wpa2 && wpaType.wpa2) {
		/* encryption mode is WPA2 */
		memcpy(util_fns, &pRsnConfig->AKM, (UINT8 *)pAkm,
		       sizeof(pRsnConfig->AKM));

		pRsnConfig->wpaType.wpa2 = 1;

		if (pRsnCap) {
			pRsnConfig->rsnCapValid = 1;
			memcpy(util_fns, &pRsnConfig->rsnCap, pRsnCap,
			       sizeof(pRsnConfig->rsnCap));
		}

		if (pGrpMgmtCipher) {
			pRsnConfig->grpMgmtCipherValid = 1;
			memcpy(util_fns, &pRsnConfig->grpMgmtCipher,
			       pGrpMgmtCipher,
			       sizeof(pRsnConfig->grpMgmtCipher));
		}
	} else if (pSecurityParams->wpaType.wpaNone && wpaType.wpaNone) {
		memcpy(util_fns, &pRsnConfig->AKM,
		       wpa_oui_none, sizeof(pRsnConfig->AKM));

		/* encryption mode is WPA None */
		pRsnConfig->wpaType.wpaNone = 1;

		if (pSecurityParams->mcstCipher.ccmp && pMcstCipher->ccmp) {
			pRsnConfig->mcstCipher.ccmp = 1;
		} else {
			pRsnConfig->mcstCipher.tkip = 1;
		}
	} else if (pSecurityParams->wpaType.wpa && wpaType.wpa) {
		/* encryption mode is WPA */
		memcpy(util_fns, &pRsnConfig->AKM, (UINT8 *)pAkm,
		       sizeof(pRsnConfig->AKM));

		pRsnConfig->wpaType.wpa = 1;
	} else if (pSecurityParams->wpaType.noRsn) {
		/* No encryption */
		pRsnConfig->wpaType.noRsn = 1;
	}

	if (pRsnConfig->wpaType.wpa || pRsnConfig->wpaType.wpa2) {
		if (pSecurityParams->ucstCipher.ccmp && pUcstCipher->ccmp) {
			pRsnConfig->ucstCipher.ccmp = 1;
		} else {
			pRsnConfig->ucstCipher.tkip = 1;
		}

		if (pSecurityParams->mcstCipher.ccmp && pMcstCipher->ccmp) {
			pRsnConfig->mcstCipher.ccmp = 1;
		} else if (pSecurityParams->mcstCipher.tkip &&
			   pMcstCipher->tkip) {
			pRsnConfig->mcstCipher.tkip = 1;
		} else if (pSecurityParams->mcstCipher.wep104 &&
			   pMcstCipher->wep104) {
			pRsnConfig->mcstCipher.wep104 = 1;
		} else {
			pRsnConfig->mcstCipher.wep40 = 1;
		}
	}

}

UINT16
keyMgmtFormatWpaRsnIe_internal(phostsa_private priv, RSNConfig_t *pRsnConfig,
			       UINT8 *pos,
			       IEEEtypes_MacAddr_t *pBssid,
			       IEEEtypes_MacAddr_t *pStaAddr,
			       UINT8 *pPmkid, BOOLEAN addPmkid)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	IEEEtypes_WPAElement_t *pWpaIe = (IEEEtypes_WPAElement_t *)pos;
	IEEEtypes_RSNElement_t *pRsnIe = (IEEEtypes_RSNElement_t *)pos;

	UINT32 ieSize = 0;
#if 0				//!defined(REMOVE_PATCH_HOOKS)
	UINT16 ptr_val;

	if (keyMgmtFormatWpaRsnIe_internal_hook(pRsnConfig,
						pos,
						pBssid,
						pStaAddr,
						pPmkid, addPmkid, &ptr_val)) {
		return ptr_val;
	}
#endif

	if (pRsnConfig->wpaType.wpa2) {
		/* encryption mode is WPA2 */
		pRsnIe->ElementId = ELEM_ID_RSN;
		pRsnIe->Len = (sizeof(pRsnIe->Ver)
			       + sizeof(pRsnIe->GrpKeyCipher)
			       + sizeof(pRsnIe->PwsKeyCnt)
			       + sizeof(pRsnIe->PwsKeyCipherList)
			       + sizeof(pRsnIe->AuthKeyCnt)
			       + sizeof(pRsnIe->AuthKeyList));

		memcpy(util_fns, (void *)pRsnIe->AuthKeyList,
		       &pRsnConfig->AKM, sizeof(pRsnIe->AuthKeyList));

		pRsnIe->Ver = 1;

		pRsnIe->PwsKeyCnt = 1;
		pRsnIe->AuthKeyCnt = 1;

		if (pRsnConfig->ucstCipher.ccmp) {
			/* unicast cipher is aes */
			memcpy(util_fns, (void *)pRsnIe->PwsKeyCipherList,
			       wpa2_oui04, sizeof(pRsnIe->PwsKeyCipherList));
		} else {
			/* if not AES the TKIP */
			memcpy(util_fns, (void *)pRsnIe->PwsKeyCipherList,
			       wpa2_oui02, sizeof(pRsnIe->PwsKeyCipherList));
		}

		if (pRsnConfig->mcstCipher.ccmp) {
			/* multicast cipher is aes */
			memcpy(util_fns, (void *)pRsnIe->GrpKeyCipher,
			       wpa2_oui04, sizeof(pRsnIe->GrpKeyCipher));
		} else if (pRsnConfig->mcstCipher.tkip) {
			/* multicast cipher is tkip */
			memcpy(util_fns, (void *)pRsnIe->GrpKeyCipher,
			       wpa2_oui02, sizeof(pRsnIe->GrpKeyCipher));
		} else if (pRsnConfig->mcstCipher.wep104) {
			/* multicast cipher is WEP 104 */
			memcpy(util_fns, (void *)pRsnIe->GrpKeyCipher,
			       wpa2_oui05, sizeof(pRsnIe->GrpKeyCipher));
		} else {
			/* multicast cipher is WEP 40 */
			memcpy(util_fns, (void *)pRsnIe->GrpKeyCipher,
			       wpa2_oui01, sizeof(pRsnIe->GrpKeyCipher));
		}
		if (addPmkid && ((!pRsnConfig->pmkidValid && pBssid) || pPmkid)) {
			if (pPmkid) {
				memcpy(util_fns, pRsnConfig->PMKID, pPmkid,
				       sizeof(pRsnConfig->PMKID));
				pRsnConfig->pmkidValid = TRUE;
			} else {
				pRsnConfig->pmkidValid =
					supplicantGetPmkid(priv, pBssid,
							   pStaAddr,
							   &pRsnConfig->AKM,
							   pRsnConfig->PMKID);
			}
		}

		if (pRsnConfig->rsnCapValid
		    || pRsnConfig->pmkidValid
		    || pRsnConfig->grpMgmtCipherValid) {
			memcpy(util_fns, &pRsnIe->RsnCap,
			       &pRsnConfig->rsnCap, sizeof(pRsnIe->RsnCap));

			pRsnIe->Len += sizeof(pRsnIe->RsnCap);
		}

		if (pRsnConfig->pmkidValid || pRsnConfig->grpMgmtCipherValid) {
			pRsnIe->PMKIDCnt = 0;
			pRsnIe->Len += sizeof(pRsnIe->PMKIDCnt);

			if (pRsnConfig->pmkidValid) {
				/* Add PMKID to the RSN if not an EAPOL msg */
				pRsnIe->PMKIDCnt = 1;

				memcpy(util_fns, (UINT8 *)pRsnIe->PMKIDList,
				       pRsnConfig->PMKID,
				       sizeof(pRsnIe->PMKIDList));

				pRsnIe->Len += sizeof(pRsnIe->PMKIDList);
			}
		}

		if (pRsnConfig->grpMgmtCipherValid) {
			memcpy(util_fns, pRsnIe->GrpMgmtCipher,
			       &pRsnConfig->grpMgmtCipher,
			       sizeof(pRsnIe->GrpMgmtCipher));

			pRsnIe->Len += sizeof(pRsnIe->GrpMgmtCipher);
		}

		ieSize = sizeof(pRsnIe->ElementId) + sizeof(pRsnIe->Len);
		ieSize += pRsnIe->Len;
	} else if (pRsnConfig->wpaType.wpaNone || pRsnConfig->wpaType.wpa) {
		/* encryption mode is WPA */
		pWpaIe->ElementId = ELEM_ID_VENDOR_SPECIFIC;
		pWpaIe->Len = (sizeof(IEEEtypes_WPAElement_t)
			       - sizeof(pWpaIe->ElementId)
			       - sizeof(pWpaIe->Len));

		memcpy(util_fns, pWpaIe->OuiType, wpa_oui01,
		       sizeof(pWpaIe->OuiType));

		pWpaIe->Ver = 1;

		pWpaIe->PwsKeyCnt = 1;
		pWpaIe->AuthKeyCnt = 1;

		memcpy(util_fns, (void *)pWpaIe->AuthKeyList,
		       &pRsnConfig->AKM, sizeof(pWpaIe->AuthKeyList));

		if (pRsnConfig->wpaType.wpaNone) {
			memcpy(util_fns, (void *)pWpaIe->PwsKeyCipherList,
			       wpa_oui_none, sizeof(pWpaIe->PwsKeyCipherList));

			if (pRsnConfig->mcstCipher.tkip) {
				/* multicast cipher is tkip */
				memcpy(util_fns, (void *)pWpaIe->GrpKeyCipher,
				       wpa_oui02, sizeof(pWpaIe->GrpKeyCipher));
			} else if (pRsnConfig->mcstCipher.ccmp) {
				/* multicast cipher is aes */
				memcpy(util_fns, (void *)pWpaIe->GrpKeyCipher,
				       wpa_oui04, sizeof(pWpaIe->GrpKeyCipher));
			}
		} else {
			if (pRsnConfig->ucstCipher.ccmp) {
				/* unicast cipher is aes */
				memcpy(util_fns,
				       (void *)pWpaIe->PwsKeyCipherList,
				       wpa_oui04,
				       sizeof(pWpaIe->PwsKeyCipherList));
			} else {
				/* unicast cipher is tkip */
				memcpy(util_fns,
				       (void *)pWpaIe->PwsKeyCipherList,
				       wpa_oui02,
				       sizeof(pWpaIe->PwsKeyCipherList));
			}

			if (pRsnConfig->mcstCipher.ccmp) {
				/* multicast cipher is aes */
				memcpy(util_fns, (void *)pWpaIe->GrpKeyCipher,
				       wpa_oui04, sizeof(pWpaIe->GrpKeyCipher));
			} else if (pRsnConfig->mcstCipher.tkip) {
				/* multicast cipher is tkip */
				memcpy(util_fns, (void *)pWpaIe->GrpKeyCipher,
				       wpa_oui02, sizeof(pWpaIe->GrpKeyCipher));
			} else if (pRsnConfig->mcstCipher.wep104) {
				/* multicast cipher is wep 104 */
				memcpy(util_fns, (void *)pWpaIe->GrpKeyCipher,
				       wpa_oui05, sizeof(pWpaIe->GrpKeyCipher));
			} else {
				/* multicast cipher is wep 40 */
				memcpy(util_fns, (void *)pWpaIe->GrpKeyCipher,
				       wpa_oui01, sizeof(pWpaIe->GrpKeyCipher));
			}
		}

		ieSize = sizeof(pWpaIe->ElementId) + sizeof(pWpaIe->Len);
		ieSize += pWpaIe->Len;
	}

	return ieSize;
}

void
install_wpa_none_keys_internal(phostsa_private priv,
			       key_MgtMaterial_t *pKeyMgtData, UINT8 *pPMK,
			       UINT8 type, UINT8 unicast)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

#if 0				//!defined(REMOVE_PATCH_HOOKS)
	if (install_wpa_none_keys_internal_hook(pKeyMgtData,
						pPMK, type, unicast)) {
		return;
	}
#endif

	memset(util_fns, (void *)pKeyMgtData, 0, sizeof(key_MgtMaterial_t));

	if (unicast) {
		pKeyMgtData->keyInfo = (KEY_INFO_MULTICAST | KEY_INFO_ENABLED);
	} else {
		pKeyMgtData->keyInfo = (KEY_INFO_UNICAST | KEY_INFO_ENABLED);
	}

	if (type) {
		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.AES.key, pPMK,
		       16);
		pKeyMgtData->keyType = KEY_TYPE_AES;
		pKeyMgtData->keyLen = WPA_AES_KEY_LEN;
	} else {
		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.TKIP.key, pPMK,
		       16);
		pPMK += 16;
		pKeyMgtData->keyType = KEY_TYPE_TKIP;

		/* in WPA none the TX & RX MIC key is the same */
		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.TKIP.txMicKey,
		       pPMK, 8);
		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.TKIP.rxMicKey,
		       pPMK, 8);

		pKeyMgtData->keyLen = WPA_TKIP_KEY_LEN;
	}

}

UINT16
keyMgmtGetKeySize_internal(RSNConfig_t *pRsnConfig, UINT8 isPairwise)
{
	/* default to TKIP key size */
	UINT16 retval = 32;

#if 0				//!defined(REMOVE_PATCH_HOOKS)
	if (keyMgmtGetKeySize_internal_hook(pRsnConfig, isPairwise, &retval)) {
		return retval;
	}
#endif

	if (isPairwise) {
		if (pRsnConfig->ucstCipher.ccmp) {
			retval = 16;
		}
	} else {
		if (pRsnConfig->mcstCipher.ccmp) {
			retval = 16;
		} else if (pRsnConfig->mcstCipher.wep104) {
			retval = 13;
		} else if (pRsnConfig->mcstCipher.wep40) {
			retval = 5;
		}
	}
	return retval;
}

//#if defined(PSK_SUPPLICANT) || defined (WPA_NONE)
void
supplicantGenerateSha1Pmkid(phostsa_private priv, UINT8 *pPMK,
			    IEEEtypes_MacAddr_t *pBssid,
			    IEEEtypes_MacAddr_t *pSta, UINT8 *pPMKID)
{
	char pmkidString[] = "PMK Name";
	void *pText[3];

	int len[3] = { 8, 6, 6 };

	pText[0] = pmkidString;
	pText[1] = pBssid;
	pText[2] = pSta;

	Mrvl_hmac_sha1((void *)priv, (UINT8 **)pText, len, 3, pPMK, 32,	/* PMK size is always 32 bytes */
		       pPMKID, 16);
}

int
isApReplayCounterFresh(phostsa_private priv, keyMgmtInfoSta_t *pKeyMgmtInfoSta,
		       UINT8 *pRxReplayCount)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	UINT32 tmpHi;
	UINT32 tmpLo;
	UINT32 rxCountHi;
	UINT32 rxCountLo;

	/* initialize the value as stale */
	int retVal = 0;

	memcpy(util_fns, &tmpHi, pRxReplayCount, 4);
	memcpy(util_fns, &tmpLo, pRxReplayCount + 4, 4);

	rxCountHi = ntohl(tmpHi);
	rxCountLo = ntohl(tmpLo);

	/* check hi dword first */
	if (rxCountHi > pKeyMgmtInfoSta->apCounterHi) {
		retVal = 1;
	} else if (rxCountHi == pKeyMgmtInfoSta->apCounterHi) {
		/* hi dword is equal, check lo dword */
		if (rxCountLo > pKeyMgmtInfoSta->apCounterLo) {
			retVal = 1;
		} else if (rxCountLo == pKeyMgmtInfoSta->apCounterLo) {

			/* Counters are equal. Check special case of zero. */
			if ((rxCountHi == 0) && (rxCountLo == 0)) {
				if (!pKeyMgmtInfoSta->apCounterZeroDone) {
					retVal = 1;
				}
			}
		}
	}

	return retVal;
}

void
updateApReplayCounter(phostsa_private priv, keyMgmtInfoSta_t *pKeyMgmtStaInfo,
		      UINT8 *pRxReplayCount)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	UINT32 tmpHi;
	UINT32 tmpLo;
	UINT32 rxCountHi;
	UINT32 rxCountLo;

	memcpy(util_fns, &tmpHi, pRxReplayCount, 4);
	memcpy(util_fns, &tmpLo, pRxReplayCount + 4, 4);

	rxCountHi = ntohl(tmpHi);
	rxCountLo = ntohl(tmpLo);

	pKeyMgmtStaInfo->apCounterHi = rxCountHi;
	pKeyMgmtStaInfo->apCounterLo = rxCountLo;

	if ((rxCountHi == 0) && (rxCountLo == 0)) {
		pKeyMgmtStaInfo->apCounterZeroDone = 1;
	}
}

void
FillKeyMaterialStruct_internal(phostsa_private priv,
			       key_MgtMaterial_t *pKeyMgtData, UINT16 key_len,
			       UINT8 isPairwise, KeyData_t *pKey)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	UINT8 keyInfo;

#if 0				//!defined(REMOVE_PATCH_HOOKS)
	if (FillKeyMaterialStruct_internal_hook(pKeyMgtData,
						key_len, isPairwise, pKey)) {
		return;
	}
#endif

	/* Update key material */
	memset(util_fns, (void *)pKeyMgtData, 0x00, sizeof(key_MgtMaterial_t));

	/* check the key type is pairwise */
	if (isPairwise) {
		keyInfo = KEY_INFO_UNICAST;
	} else {
		keyInfo = KEY_INFO_MULTICAST;
	}

	if (key_len == (UINT16)WPA_AES_KEY_LEN) {
		/* AES */
		pKeyMgtData->keyType = KEY_TYPE_AES;
		pKeyMgtData->keyInfo = keyInfo | KEY_INFO_ENABLED;

		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.AES.key,
		       pKey->Key, key_len);

	} else if (key_len == WPA_TKIP_KEY_LEN) {
		pKeyMgtData->keyType = KEY_TYPE_TKIP;
		pKeyMgtData->keyInfo = keyInfo | KEY_INFO_ENABLED;

		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.TKIP.key,
		       pKey->Key, TK_SIZE);
		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.TKIP.txMicKey,
		       pKey->TxMICKey, 8);
		memcpy(util_fns, (UINT8 *)pKeyMgtData->keyEncypt.TKIP.rxMicKey,
		       pKey->RxMICKey, 8);
	} else if (key_len == WPA_WEP104_KEY_LEN ||
		   key_len == WPA_WEP40_KEY_LEN) {
		pKeyMgtData->keyType = KEY_TYPE_WEP;
		pKeyMgtData->keyInfo = keyInfo | KEY_INFO_ENABLED;

		if (isPairwise) {
			pKeyMgtData->keyEncypt.WEP.keyIndex = 0;
			pKeyMgtData->keyEncypt.WEP.isDefaultTx = 1;
		} else {
			/* use the Key index provided */
			pKeyMgtData->keyEncypt.WEP.keyIndex = pKey->KeyIndex;
			pKeyMgtData->keyEncypt.WEP.isDefaultTx = 0;
		}
		memcpy(util_fns, (UINT8 *)(pKeyMgtData->keyEncypt.WEP.key),
		       pKey->Key, key_len);
	} else {
		/* Key length does not match
		 ** don't send down anything
		 */
		return;
	}

	pKeyMgtData->keyLen = key_len;
}

//#endif

/*
**  This function checks if the given element pointer parameter
**  is a KDE or not (returns NULL)
*/
KDE_t *
parseKeyKDE(phostsa_private priv, IEEEtypes_InfoElementHdr_t *pIe)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	KDE_t *pKde = NULL;

	if (pIe->ElementId == ELEM_ID_VENDOR_SPECIFIC) {
		pKde = (KDE_t *)pIe;

		if (pKde->length > sizeof(KDE_t) &&
		    !memcmp(util_fns, (void *)pKde->OUI, kde_oui,
			    sizeof(kde_oui))) {
			return pKde;
		}
	}

	return NULL;

}

/* This function searches KDE_DATA_TYPE_XXX in KDE. We can collect all such
**  KDE_DATA_TYPE_XXX in one pass, however, there seems not much benefit
**  as in general there would not be many KDE_DATA_TYPE_XXX present.
**  Returns NULL, when KDE_DATA_TYPE_XXX not found.
*/

KDE_t *
parseKeyKDE_DataType(phostsa_private priv, UINT8 *pData,
		     SINT32 dataLen, IEEEtypes_KDEDataType_e KDEDataType)
{

	IEEEtypes_InfoElementHdr_t *pIe;
	KDE_t *pKde;
#if 0				//!defined(REMOVE_PATCH_HOOKS)
	UINT32 ptr_val;

	if (parseKeyKDE_DataType_hook(pData, dataLen, KDEDataType, &ptr_val)) {
		return (KDE_t *)ptr_val;
	}
#endif

	if (pData == NULL) {
		return NULL;
	}

	while (dataLen > (SINT32)sizeof(IEEEtypes_InfoElementHdr_t)) {
		pIe = (IEEEtypes_InfoElementHdr_t *)pData;

		if (pIe->ElementId == ELEM_ID_VENDOR_SPECIFIC) {
			pKde = parseKeyKDE(priv, pIe);

			if ((pKde != NULL) && (pKde->dataType == KDEDataType)) {
				return pKde;
			} else if (pIe->Len == 0) {
				/* the rest is padding, so adjust the length
				 ** to stop the processing loop
				 */
				dataLen = sizeof(IEEEtypes_InfoElementHdr_t);
			}
		}

		dataLen -= (pIe->Len + sizeof(IEEEtypes_InfoElementHdr_t));
		pData += (pIe->Len + sizeof(IEEEtypes_InfoElementHdr_t));
	}

	return NULL;
}

KDE_t *
parseKeyDataGTK(phostsa_private priv, UINT8 *pKey, UINT16 len,
		KeyData_t *pGRKey)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	GTK_KDE_t *pGtk;
	KDE_t *pKde;
#if 0				//!defined(REMOVE_PATCH_HOOKS)
	UINT32 ptr_val;

	if (parseKeyDataGTK_hook(pKey, len, pGRKey, &ptr_val)) {
		return (KDE_t *)ptr_val;
	}
#endif

	/* parse KDE GTK */
	pKde = parseKeyKDE_DataType(priv, pKey, len, KDE_DATA_TYPE_GTK);

	if (pKde) {
		/* GTK KDE */
		pGtk = (GTK_KDE_t *)pKde->data;

		/* The KDE overhead is 6 bytes */
		memcpy(util_fns, pGRKey->Key, (void *)pGtk->GTK,
		       pKde->length - 6);

		/* save the group key index */
		pGRKey->KeyIndex = pGtk->KeyID;
	}

	return pKde;
}

void
KeyMgmtSta_ApplyKEK(phostsa_private priv, EAPOL_KeyMsg_t *pKeyMsg,
		    KeyData_t *pGRKey, UINT8 *EAPOL_Encr_Key)
{
#if 0
#if !defined(REMOVE_PATCH_HOOKS)
	if (KeyMgmtSta_ApplyKEK_hook(pKeyMsg, pGRKey, EAPOL_Encr_Key)) {
		return;
	}
#endif
#endif
	pGRKey->TxIV16 = pKeyMsg->key_RSC[1] << 8;
	pGRKey->TxIV16 |= pKeyMsg->key_RSC[0];
	pGRKey->TxIV32 = 0xFFFFFFFF;

	pKeyMsg->key_material_len = ntohs(pKeyMsg->key_material_len) & 0xFFFF;

	switch (pKeyMsg->key_info.KeyDescriptorVersion) {
		/*
		 ** Key Descriptor Version 2 or 3: AES key wrap, defined in IETF
		 **   RFC 3394, shall be used to encrypt the Key Data field using
		 **   the KEK field from the derived PTK.
		 */
	case 3:
	case 2:
		/* CCMP */
		MRVL_AesUnWrap(EAPOL_Encr_Key,
			       2,
			       pKeyMsg->key_material_len / 8 - 1,
			       (UINT8 *)pKeyMsg->key_data,
			       NULL, (UINT8 *)pKeyMsg->key_data);

		/* AES key wrap has 8 extra bytes that come out
		 ** due to the default IV
		 */
		pKeyMsg->key_material_len -= 8;
		break;

		/*
		 ** Key Descriptor Version 1: ARC4 is used to encrypt the Key Data
		 **   field using the KEK field from the derived PTK
		 */
	default:
	case 1:
		/* TKIP or WEP */
		/* Skip the first 256 bytes of the RC4 Stream */
		RC4_Encrypt((void *)priv, EAPOL_Encr_Key,
			    (UINT8 *)pKeyMsg->EAPOL_key_IV,
			    sizeof(pKeyMsg->EAPOL_key_IV),
			    (UINT8 *)pKeyMsg->key_data,
			    pKeyMsg->key_material_len, 256);
		break;
	}

}

/*
**  Verifies the received EAPOL frame during 4-way handshake or
**  group key handshake
*/
BOOLEAN
KeyMgmtSta_IsRxEAPOLValid(phostsa_private priv,
			  keyMgmtInfoSta_t *pKeyMgmtInfoSta,
			  EAPOL_KeyMsg_t *pKeyMsg)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

#if 0				//!defined(REMOVE_PATCH_HOOKS)
	BOOLEAN ptr_val;

	if (KeyMgmtSta_IsRxEAPOLValid_hook(pKeyMgmtInfoSta, pKeyMsg, &ptr_val)) {
		return ptr_val;
	}
#endif

	if (!pKeyMgmtInfoSta || !pKeyMsg) {
		PRINTM(MERROR, "KeyMgmtSta_IsRxEAPOLValid input not valid\n");
		return FALSE;
	}

	if (!isApReplayCounterFresh
	    (priv, pKeyMgmtInfoSta, (UINT8 *)pKeyMsg->replay_cnt)) {
		PRINTM(MERROR,
		       "KeyMgmtSta_IsRxEAPOLValid isApReplayCounterFresh Fail\n");
		return FALSE;
	}

	/* Check if we have to verify MIC */

	if (pKeyMsg->key_info.KeyMIC) {
		/* We have to verify MIC, if keyType is 1 it's the 3rd message in
		   4-way handshake, in that case verify ANonce.
		 */

		if ((pKeyMsg->key_info.KeyType == 1) &&
		    memcmp(util_fns, (UINT8 *)&pKeyMsg->key_nonce,
			   (UINT8 *)pKeyMgmtInfoSta->ANonce, NONCE_SIZE) != 0) {
			/* Dropping the packet, return some error msg. */
			PRINTM(MERROR,
			       "KeyMgmtSta_IsRxEAPOLValid Nonce check Fail\n");
			return FALSE;
		}

		if (!IsEAPOL_MICValid
		    (priv, pKeyMsg, pKeyMgmtInfoSta->EAPOL_MIC_Key)) {
			/* MIC failed */
			PRINTM(MERROR,
			       "KeyMgmtSta_IsRxEAPOLValid MIC check Fail\n");
			return FALSE;
		}

	}
	return TRUE;

}

/*
**  This function populates EAPOL frame fileds that are common
**  to message 2, 4 of 4-way handshake and group key hadshake
**  message 2.
**  Any of these fields in general should not change, and if needed
**  can be overwritten in the caller function.
*/
void
KeyMgmtSta_PrepareEAPOLFrame(phostsa_private priv, EAPOL_KeyMsg_Tx_t *pTxEapol,
			     EAPOL_KeyMsg_t *pRxEapol,
			     t_u8 *da, t_u8 *sa, UINT8 *pSNonce)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

	if (!pTxEapol || !pRxEapol) {
		return;
	}
	memset(util_fns, (UINT8 *)pTxEapol, 0x00, sizeof(EAPOL_KeyMsg_Tx_t));

	formEAPOLEthHdr(priv, pTxEapol, da, sa);

	pTxEapol->keyMsg.desc_type = pRxEapol->desc_type;
	pTxEapol->keyMsg.key_info.KeyType = pRxEapol->key_info.KeyType;
	pTxEapol->keyMsg.key_info.KeyMIC = 1;
	pTxEapol->keyMsg.key_info.Secure = pRxEapol->key_info.Secure;
	pTxEapol->keyMsg.replay_cnt[0] = pRxEapol->replay_cnt[0];
	pTxEapol->keyMsg.replay_cnt[1] = pRxEapol->replay_cnt[1];

	pTxEapol->keyMsg.key_info.KeyDescriptorVersion
		= pRxEapol->key_info.KeyDescriptorVersion;

	// Only for  4-w handshake message 2.
	if (pSNonce) {
		memcpy(util_fns, (UINT8 *)pTxEapol->keyMsg.key_nonce, pSNonce,
		       NONCE_SIZE);
	}
}

void
KeyMgmtSta_PrepareEAPOLMicErrFrame(phostsa_private priv,
				   EAPOL_KeyMsg_Tx_t *pTxEapol,
				   BOOLEAN isUnicast, IEEEtypes_MacAddr_t *da,
				   IEEEtypes_MacAddr_t *sa,
				   keyMgmtInfoSta_t *pKeyMgmtInfoSta)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

	if (!pTxEapol || !pKeyMgmtInfoSta) {
		return;
	}

	memset(util_fns, (UINT8 *)pTxEapol, 0x00, sizeof(EAPOL_KeyMsg_Tx_t));

	formEAPOLEthHdr(priv, pTxEapol, (t_u8 *)da, (t_u8 *)sa);

	pTxEapol->keyMsg.key_info.KeyType = isUnicast;
	pTxEapol->keyMsg.key_info.KeyMIC = 1;
	pTxEapol->keyMsg.key_info.Secure = 1;
	pTxEapol->keyMsg.key_info.Error = 1;
	pTxEapol->keyMsg.key_info.Request = 1;
	pTxEapol->keyMsg.replay_cnt[0] = htonl(pKeyMgmtInfoSta->staCounterHi);
	pTxEapol->keyMsg.replay_cnt[1] = htonl(pKeyMgmtInfoSta->staCounterLo);

}

BOOLEAN
supplicantAkmIsWpaWpa2(phostsa_private priv, AkmSuite_t *pAkm)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

	if (!memcmp(util_fns, pAkm->akmOui, wpa_oui, sizeof(wpa_oui)) ||
	    !memcmp(util_fns, pAkm->akmOui, kde_oui, sizeof(kde_oui))) {
		return TRUE;
	}

	return FALSE;
}

BOOLEAN
supplicantAkmIsWpa2(phostsa_private priv, AkmSuite_t *pAkm)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

	if (memcmp(util_fns, pAkm->akmOui, kde_oui, sizeof(kde_oui)) == 0) {
		return TRUE;
	}

	return FALSE;
}

BOOLEAN
supplicantAkmIsWpaWpa2Psk(phostsa_private priv, AkmSuite_t *pAkm)
{
	if (supplicantAkmIsWpaWpa2(priv, pAkm)) {
		return ((pAkm->akmType == AKM_PSK) ||
			(pAkm->akmType == AKM_SHA256_PSK) ||
			(pAkm->akmType == AKM_FT_PSK));
	}

	return FALSE;
}

BOOLEAN
supplicantAkmUsesKdf(phostsa_private priv, AkmSuite_t *pAkm)
{
	if (supplicantAkmIsWpa2(priv, pAkm)) {
		if ((pAkm->akmType == AKM_SHA256_PSK) ||
		    (pAkm->akmType == AKM_SHA256_1X) ||
		    (pAkm->akmType == AKM_FT_PSK) ||
		    (pAkm->akmType == AKM_FT_1X)) {
			return TRUE;
		}
	}

	return FALSE;
}

BOOLEAN
supplicantAkmWpa2Ft(phostsa_private priv, AkmSuite_t *pAkm)
{
	if (supplicantAkmIsWpa2(priv, pAkm)) {
		if ((pAkm->akmType == AKM_FT_PSK) ||
		    (pAkm->akmType == AKM_FT_1X)) {
			return TRUE;
		}
	}

	return FALSE;
}

BOOLEAN
supplicantAkmUsesSha256Pmkid(phostsa_private priv, AkmSuite_t *pAkm)
{
	if (supplicantAkmIsWpa2(priv, pAkm)) {
		if ((pAkm->akmType == AKM_SHA256_PSK) ||
		    (pAkm->akmType == AKM_SHA256_1X)) {
			return TRUE;
		}
	}

	return FALSE;
}

void
supplicantGenerateSha256Pmkid(phostsa_private priv, UINT8 *pPMK,
			      IEEEtypes_MacAddr_t *pBssid,
			      IEEEtypes_MacAddr_t *pSta, UINT8 *pPMKID)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	UINT8 *pOutput;
	UINT8 *vectors[3];
	size_t vectLen[NELEMENTS(vectors)];
	UINT8 buf[500] = { 0 };

	pOutput = (UINT8 *)buf;

	/*
	 **  PMKID = Truncate-128(SHA-256("PMK Name" || AA || SPA)
	 */
	vectors[0] = (UINT8 *)"PMK Name";
	vectLen[0] = 8;		/* strlen("PMK Name") */

	vectors[1] = (UINT8 *)pBssid;
	vectLen[1] = sizeof(IEEEtypes_MacAddr_t);

	vectors[2] = (UINT8 *)pSta;
	vectLen[2] = sizeof(IEEEtypes_MacAddr_t);

	mrvl_sha256_crypto_vector((void *)priv, NELEMENTS(vectors), vectors,
				  vectLen, pOutput);

	memcpy(util_fns, pPMKID, pOutput, PMKID_LEN);

}

BOOLEAN
supplicantGetPmkid(phostsa_private priv, IEEEtypes_MacAddr_t *pBssid,
		   IEEEtypes_MacAddr_t *pStaAddr,
		   AkmSuite_t *pAkm, UINT8 *pPMKID)
{
	BOOLEAN retval;
	UINT8 *pPMK;

	retval = FALSE;

	if (!supplicantAkmIsWpaWpa2Psk(priv, pAkm)) {
		pPMK = pmkCacheFindPMK((void *)priv, pBssid);

		/* found the PMK so generate the PMKID */
		if (pPMK) {
			if (supplicantAkmUsesSha256Pmkid(priv, pAkm)) {
				supplicantGenerateSha256Pmkid(priv, pPMK,
							      pBssid, pStaAddr,
							      pPMKID);
			} else {
				supplicantGenerateSha1Pmkid(priv, pPMK, pBssid,
							    pStaAddr, pPMKID);
			}

			retval = TRUE;
		}
	}

	return retval;
}

EAPOL_KeyMsg_t *
GetKeyMsgNonceFromEAPOL(phostsa_private priv, mlan_buffer *pmbuf,
			keyMgmtInfoSta_t *pKeyMgmtInfoSta)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	EAPOL_KeyMsg_t *pKeyMsg =
		(EAPOL_KeyMsg_t *)(pmbuf->pbuf + pmbuf->data_offset +
				   sizeof(ether_hdr_t));;

	if (!KeyMgmtSta_IsRxEAPOLValid(priv, pKeyMgmtInfoSta, pKeyMsg)) {
		PRINTM(MERROR, "KeyMgmtSta_IsRxEAPOLValid Fail\n");
		return NULL;
	}
	/* Generate Nonce if this is first PWK Message */
	if (pKeyMsg->key_info.KeyMIC == 0) {
		memcpy(util_fns, pKeyMgmtInfoSta->ANonce,
		       pKeyMsg->key_nonce, NONCE_SIZE);

		supplicantGenerateRand(priv, pKeyMgmtInfoSta->SNonce,
				       NONCE_SIZE);
	}
	return pKeyMsg;
}

#ifndef WAR_ROM_BUG50312_SIMUL_INFRA_WFD
EAPOL_KeyMsg_t *
ProcessRxEAPOL_PwkMsg3(phostsa_private priv, mlan_buffer *pmbuf,
		       keyMgmtInfoSta_t *pKeyMgmtInfoSta)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

	EAPOL_KeyMsg_t *pKeyMsg;

	pKeyMsg = GetKeyMsgNonceFromEAPOL(priv, pmbuf, pKeyMgmtInfoSta);
	if (!pKeyMsg) {
		PRINTM(MERROR, "ProcessRxEAPOL_PwkMsg3 pKeyMsg is NULL\n");
		return NULL;
	}
	pKeyMgmtInfoSta->newPWKey.TxIV16 = 1;
	pKeyMgmtInfoSta->newPWKey.TxIV32 = 0;

	/* look for group key once the pairwise has been plumbed */
	if (pKeyMsg->key_info.EncryptedKeyData) {
		/* I think the timer stop should be moved later on
		   in case ramHook_Process_CCX_MFP_11r returns
		   FALSE
		 */

//        microTimerStop(pKeyMgmtInfoSta->rsnTimer);
		util_fns->moal_stop_timer(util_fns->pmoal_handle,
					  pKeyMgmtInfoSta->rsnTimer);
		//pKeyMgmtInfoSta->rsnTimer = 0;

		KeyMgmtSta_ApplyKEK(priv, pKeyMsg,
				    &pKeyMgmtInfoSta->GRKey,
				    pKeyMgmtInfoSta->EAPOL_Encr_Key);
#if 0
		if (ramHook_keyMgmtProcessMsgExt(pKeyMgmtInfoSta, pKeyMsg) ==
		    FALSE) {
			return NULL;
		}
#endif
		parseKeyDataGTK(priv, pKeyMsg->key_data,
				pKeyMsg->key_material_len,
				&pKeyMgmtInfoSta->GRKey);

	}
	return pKeyMsg;
}
#endif

#ifndef WAR_ROM_BUG50312_SIMUL_INFRA_WFD
EAPOL_KeyMsg_t *
ProcessRxEAPOL_GrpMsg1(phostsa_private priv, mlan_buffer *pmbuf,
		       keyMgmtInfoSta_t *pKeyMgmtInfoSta)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	EAPOL_KeyMsg_t *pKeyMsg;
	KeyData_t GRKey;
	pKeyMsg = GetKeyMsgNonceFromEAPOL(priv, pmbuf, pKeyMgmtInfoSta);
	if (!pKeyMsg) {
		return NULL;
	}

	KeyMgmtSta_ApplyKEK(priv, pKeyMsg,
			    &pKeyMgmtInfoSta->GRKey,
			    pKeyMgmtInfoSta->EAPOL_Encr_Key);

	pKeyMgmtInfoSta->RSNDataTrafficEnabled = 1;
	//microTimerStop(pKeyMgmtInfoSta->rsnTimer);
	util_fns->moal_stop_timer(util_fns->pmoal_handle,
				  pKeyMgmtInfoSta->rsnTimer);
	//pKeyMgmtInfoSta->rsnTimer = 0;

	/* Decrypt the group key */
	if (pKeyMsg->desc_type == 2) {
		/* WPA2 */
		/* handle it according to 802.11i GTK frame format */
		parseKeyDataGTK(priv, pKeyMsg->key_data,
				pKeyMsg->key_material_len, &GRKey);
		/* Not install same GTK */
		if (!memcmp
		    (util_fns, pKeyMgmtInfoSta->GRKey.Key, GRKey.Key,
		     TK_SIZE)) {
			priv->gtk_installed = 1;
		} else {
			memcpy(util_fns, &pKeyMgmtInfoSta->GRKey, &GRKey,
			       sizeof(KeyData_t));
			pKeyMgmtInfoSta->GRKey.TxIV16 = GRKey.TxIV16;
			pKeyMgmtInfoSta->GRKey.TxIV32 = 0xFFFFFFFF;
			priv->gtk_installed = 0;
		}
#if 0
		if (ramHook_keyMgmtProcessMsgExt(pKeyMgmtInfoSta, pKeyMsg) ==
		    FALSE) {
			return NULL;
		}
#endif
	} else {
		/* WPA or Dynamic WEP */
		if (!memcmp
		    (util_fns, pKeyMgmtInfoSta->GRKey.Key, pKeyMsg->key_data,
		     pKeyMsg->key_material_len)) {
			priv->gtk_installed = 1;
		} else {
			memcpy(util_fns, pKeyMgmtInfoSta->GRKey.Key,
			       pKeyMsg->key_data, pKeyMsg->key_material_len);

			pKeyMgmtInfoSta->GRKey.KeyIndex =
				pKeyMsg->key_info.KeyIndex;
		}
	}

	return pKeyMsg;
}
#endif

void
KeyMgmtResetCounter(keyMgmtInfoSta_t *pKeyMgmtInfo)
{
	if (pKeyMgmtInfo) {
		pKeyMgmtInfo->staCounterHi = 0;
		pKeyMgmtInfo->staCounterLo = 0;
	}
}

/*
**  This code executes when the MIC failure timer timesout
*/
void
MicErrTimerExp_Sta(t_void *context)
{
	phostsa_private psapriv = (phostsa_private)context;
	keyMgmtInfoSta_t *pKeyMgmtInfo = &psapriv->suppData->keyMgmtInfoSta;

	if (pKeyMgmtInfo) {
		//if (pKeyMgmtInfo->micTimer == timerId)
		{
			if (pKeyMgmtInfo->sta_MIC_Error.status
			    == SECOND_MIC_FAIL_IN_60_SEC) {
				//ramHook_keyMgmtSendTkipQuietOver(data);
			}

			pKeyMgmtInfo->sta_MIC_Error.status = NO_MIC_FAILURE;
			pKeyMgmtInfo->sta_MIC_Error.disableStaAsso = 0;
		}

		pKeyMgmtInfo->micTimer = 0;
	}
}

void
DeauthDelayTimerExp_Sta(t_void *context)
{
	phostsa_private psapriv = (phostsa_private)context;
	keyMgmtInfoSta_t *pKeyMgmtInfoSta = &psapriv->suppData->keyMgmtInfoSta;

	if (pKeyMgmtInfoSta) {
		//if (pKeyMgmtInfoSta->deauthDelayTimer == timerId)
		{
			if (pKeyMgmtInfoSta->sta_MIC_Error.status
			    == SECOND_MIC_FAIL_IN_60_SEC) {
				//ramHook_keyMgmtSendDeauth(psapriv,
				//                          IEEEtypes_REASON_MIC_FAILURE);
				keyMgmtSendDeauth2Peer(psapriv,
						       IEEEtypes_REASON_MIC_FAILURE);
			}
		}

		pKeyMgmtInfoSta->deauthDelayTimer = 0;
	}
}

/*
**  Key Management timeout handler
*/
void
keyMgmtStaRsnSecuredTimeoutHandler(t_void *context)
{
	phostsa_private psapriv = (phostsa_private)context;
	keyMgmtInfoSta_t *pKeyMgmtInfoSta = &psapriv->suppData->keyMgmtInfoSta;

	if (pKeyMgmtInfoSta) {
		//if (pKeyMgmtInfoSta->rsnTimer == timerId)
		{
			if (pKeyMgmtInfoSta->RSNSecured == FALSE) {
				/* Clear timer before calling the timeout so the rsnTimer
				 **  can't be cancelled during the sme state clearing.
				 **  (caused timer re-entrancy failure).
				 */
				//pKeyMgmtInfoSta->rsnTimer = 0;
				//ramHook_keyMgmtSendDeauth(
				//    psapriv,
				//    IEEEtypes_REASON_4WAY_HANDSHK_TIMEOUT);
				keyMgmtSendDeauth2Peer(psapriv,
						       IEEEtypes_REASON_4WAY_HANDSHK_TIMEOUT);
			}
		}
		//pKeyMgmtInfoSta->rsnTimer = 0;
	}
}

void
keyMgmtSta_StartSession_internal(phostsa_private priv,
				 keyMgmtInfoSta_t *pKeyMgmtInfoSta,
				 //MicroTimerCallback_t callback,
				 UINT32 expiry, UINT8 flags)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

	if (!pKeyMgmtInfoSta->sta_MIC_Error.disableStaAsso) {
		//microTimerStop(pKeyMgmtInfoSta->rsnTimer);
		util_fns->moal_stop_timer(util_fns->pmoal_handle,
					  pKeyMgmtInfoSta->rsnTimer);
		//pKeyMgmtInfoSta->rsnTimer = 0;
		//microTimerStart(callback,
		//                 (UINT32)pKeyMgmtInfoSta,
		//                 expiry,
		//                 &pKeyMgmtInfoSta->rsnTimer,
		//                 flags);
		util_fns->moal_start_timer(util_fns->pmoal_handle,
					   pKeyMgmtInfoSta->rsnTimer, MFALSE,
					   expiry);
	}

	/* reset the authenticator replay counter */
	pKeyMgmtInfoSta->apCounterLo = 0;
	pKeyMgmtInfoSta->apCounterHi = 0;
	pKeyMgmtInfoSta->apCounterZeroDone = 0;
}

void
KeyMgmtSta_handleMICDeauthTimer(keyMgmtInfoSta_t *pKeyMgmtInfoSta,
				MicroTimerCallback_t callback,
				UINT32 expiry, UINT8 flags)
{
#if 0
	microTimerStop(pKeyMgmtInfoSta->deauthDelayTimer);

	microTimerStart(callback,
			(UINT32)pKeyMgmtInfoSta,
			expiry, &pKeyMgmtInfoSta->deauthDelayTimer, flags);
#endif
}

#ifndef WAR_ROM_BUG57216_QUIET_TIME_INTERVAL
/* This function assumes that argument state would be either
    NO_MIC_FAILURE or FIRST_MIC_FAIL_IN_60_SEC
    It must not be called with state othe than these two
*/
void
KeyMgmtSta_handleMICErr(MIC_Fail_State_e state,
			keyMgmtInfoSta_t *pKeyMgmtInfoSta,
			MicroTimerCallback_t callback, UINT8 flags)
{
	UINT32 expiry;
//    UINT32 int_save = tx_interrupt_control(TX_INT_DISABLE);

	if (state == NO_MIC_FAILURE) {
		/* First MIC failure */
		pKeyMgmtInfoSta->sta_MIC_Error.status =
			FIRST_MIC_FAIL_IN_60_SEC;
		expiry = MIC_ERROR_CHECK_TIME_INTERVAL;
	} else {
		/* Received 2 MIC failures within 60 sec. Do deauth from AP */
		pKeyMgmtInfoSta->sta_MIC_Error.disableStaAsso = 1;
		pKeyMgmtInfoSta->sta_MIC_Error.status =
			SECOND_MIC_FAIL_IN_60_SEC;
		pKeyMgmtInfoSta->apCounterHi = 0;
		pKeyMgmtInfoSta->apCounterLo = 0;
		expiry = MIC_ERROR_QUIET_TIME_INTERVAL;
	}
//    tx_interrupt_control(int_save);
#if 0
	microTimerStop(pKeyMgmtInfoSta->micTimer);

	microTimerStart(callback,
			(UINT32)pKeyMgmtInfoSta,
			expiry, &pKeyMgmtInfoSta->micTimer, flags);
#endif
}
#endif

/*
**  Initialize the Key Mgmt session
*/
void
KeyMgmtSta_InitSession(phostsa_private priv, keyMgmtInfoSta_t *pKeyMgmtInfoSta)
{
	hostsa_util_fns *util_fns = &priv->util_fns;

	pKeyMgmtInfoSta->RSNDataTrafficEnabled = FALSE;
	pKeyMgmtInfoSta->RSNSecured = FALSE;
	pKeyMgmtInfoSta->pRxDecryptKey = NULL;
	pKeyMgmtInfoSta->pwkHandshakeComplete = FALSE;

	if (!pKeyMgmtInfoSta->sta_MIC_Error.disableStaAsso) {
//        microTimerStop(pKeyMgmtInfoSta->micTimer);
		pKeyMgmtInfoSta->micTimer = 0;
//        microTimerStop(pKeyMgmtInfoSta->deauthDelayTimer);
		pKeyMgmtInfoSta->deauthDelayTimer = 0;
	}
//    microTimerStop(pKeyMgmtInfoSta->rsnTimer);
	util_fns->moal_stop_timer(util_fns->pmoal_handle,
				  pKeyMgmtInfoSta->rsnTimer);

	//pKeyMgmtInfoSta->rsnTimer = 0;
}