| /* |
| * Copyright (c) 2011-2017 The Linux Foundation. All rights reserved. |
| * |
| * Previously licensed under the ISC license by Qualcomm Atheros, Inc. |
| * |
| * |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all |
| * copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| * PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| /* |
| * This file was originally distributed by Qualcomm Atheros, Inc. |
| * under proprietary terms before Copyright ownership was assigned |
| * to the Linux Foundation. |
| */ |
| |
| /**========================================================================= |
| |
| \file limSession.c |
| |
| \brief implementation for lim Session related APIs |
| |
| \author Sunit Bhatia |
| |
| ========================================================================*/ |
| |
| |
| /*-------------------------------------------------------------------------- |
| Include Files |
| ------------------------------------------------------------------------*/ |
| #include "aniGlobal.h" |
| #include "limDebug.h" |
| #ifdef WLAN_FEATURE_VOWIFI_11R |
| #include "limFTDefs.h" |
| #include "limFT.h" |
| #endif |
| #include "limSession.h" |
| #include "limUtils.h" |
| #if defined(FEATURE_WLAN_ESE) && !defined(FEATURE_WLAN_ESE_UPLOAD) |
| #include "eseApi.h" |
| #endif |
| |
| #include "pmmApi.h" |
| #include "schApi.h" |
| #include "limSendMessages.h" |
| |
| /*-------------------------------------------------------------------------- |
| |
| \brief peInitBeaconParams() - Initialize the beaconParams structure |
| |
| |
| \param tpPESession - pointer to the session context or NULL if session can not be created. |
| \return void |
| \sa |
| |
| --------------------------------------------------------------------------*/ |
| |
| void peInitBeaconParams(tpAniSirGlobal pMac, tpPESession psessionEntry) |
| { |
| psessionEntry->beaconParams.beaconInterval = 0; |
| psessionEntry->beaconParams.fShortPreamble = 0; |
| psessionEntry->beaconParams.llaCoexist = 0; |
| psessionEntry->beaconParams.llbCoexist = 0; |
| psessionEntry->beaconParams.llgCoexist = 0; |
| psessionEntry->beaconParams.ht20Coexist = 0; |
| psessionEntry->beaconParams.llnNonGFCoexist = 0; |
| psessionEntry->beaconParams.fRIFSMode = 0; |
| psessionEntry->beaconParams.fLsigTXOPProtectionFullSupport = 0; |
| psessionEntry->beaconParams.gHTObssMode = 0; |
| |
| // Number of legacy STAs associated |
| vos_mem_set((void*)&psessionEntry->gLim11bParams, sizeof(tLimProtStaParams), 0); |
| vos_mem_set((void*)&psessionEntry->gLim11aParams, sizeof(tLimProtStaParams), 0); |
| vos_mem_set((void*)&psessionEntry->gLim11gParams, sizeof(tLimProtStaParams), 0); |
| vos_mem_set((void*)&psessionEntry->gLimNonGfParams, sizeof(tLimProtStaParams), 0); |
| vos_mem_set((void*)&psessionEntry->gLimHt20Params, sizeof(tLimProtStaParams), 0); |
| vos_mem_set((void*)&psessionEntry->gLimLsigTxopParams, sizeof(tLimProtStaParams), 0); |
| vos_mem_set((void*)&psessionEntry->gLimOlbcParams, sizeof(tLimProtStaParams), 0); |
| } |
| |
| /** |
| * pe_reset_protection_callback() - resets protection structs so that when an AP |
| * causing use of protection goes away, corresponding protection bit can be |
| * reset |
| * @ptr: pointer to pSessionEntry |
| * |
| * This function resets protection structs so that when an AP causing use of |
| * protection goes away, corresponding protection bit can be reset. This allowes |
| * protection bits to be reset once legacy overlapping APs are gone. |
| * |
| * Return: void |
| */ |
| void pe_reset_protection_callback(void *ptr) |
| { |
| tpPESession pe_session_entry = (tpPESession)ptr; |
| tpAniSirGlobal mac_ctx = (tpAniSirGlobal)pe_session_entry->mac_ctx; |
| int8_t i = 0; |
| tUpdateBeaconParams beacon_params; |
| tANI_U16 current_protection_state = 0; |
| tpDphHashNode station_hash_node = NULL; |
| tSirMacHTOperatingMode old_op_mode; |
| bool bcn_prms_changed = false; |
| |
| if (pe_session_entry->valid == false) { |
| VOS_TRACE(VOS_MODULE_ID_PE, |
| VOS_TRACE_LEVEL_ERROR, |
| FL("session already deleted. exiting timer callback")); |
| return; |
| } |
| |
| current_protection_state |= |
| pe_session_entry->gLimOverlap11gParams.protectionEnabled | |
| pe_session_entry->gLimOverlap11aParams.protectionEnabled << 1 | |
| pe_session_entry->gLimOverlapHt20Params.protectionEnabled << 2 | |
| pe_session_entry->gLimOverlapNonGfParams.protectionEnabled << 3 | |
| pe_session_entry->gLimOlbcParams.protectionEnabled << 4 ; |
| |
| VOS_TRACE(VOS_MODULE_ID_PE, |
| VOS_TRACE_LEVEL_INFO, |
| FL("old protection state: 0x%04X, new protection state: 0x%04X"), |
| pe_session_entry->old_protection_state, |
| current_protection_state); |
| |
| vos_mem_zero(&pe_session_entry->gLimOverlap11gParams, |
| sizeof(pe_session_entry->gLimOverlap11gParams)); |
| vos_mem_zero(&pe_session_entry->gLimOverlap11aParams, |
| sizeof(pe_session_entry->gLimOverlap11aParams)); |
| vos_mem_zero(&pe_session_entry->gLimOverlapHt20Params, |
| sizeof(pe_session_entry->gLimOverlapHt20Params)); |
| vos_mem_zero(&pe_session_entry->gLimOverlapNonGfParams, |
| sizeof(pe_session_entry->gLimOverlapNonGfParams)); |
| |
| vos_mem_zero(&pe_session_entry->gLimOlbcParams, |
| sizeof(pe_session_entry->gLimOlbcParams)); |
| /* |
| * Do not reset fShortPreamble and beaconInterval, as they |
| * are not updated. |
| */ |
| pe_session_entry->beaconParams.llaCoexist = 0; |
| pe_session_entry->beaconParams.llbCoexist = 0; |
| pe_session_entry->beaconParams.llgCoexist = 0; |
| pe_session_entry->beaconParams.ht20Coexist = 0; |
| pe_session_entry->beaconParams.llnNonGFCoexist = 0; |
| pe_session_entry->beaconParams.fRIFSMode = 0; |
| pe_session_entry->beaconParams.fLsigTXOPProtectionFullSupport = 0; |
| pe_session_entry->beaconParams.gHTObssMode = 0; |
| |
| vos_mem_zero(&mac_ctx->lim.gLimOverlap11gParams, |
| sizeof(mac_ctx->lim.gLimOverlap11gParams)); |
| vos_mem_zero(&mac_ctx->lim.gLimOverlap11aParams, |
| sizeof(mac_ctx->lim.gLimOverlap11aParams)); |
| vos_mem_zero(&mac_ctx->lim.gLimOverlapHt20Params, |
| sizeof(mac_ctx->lim.gLimOverlapHt20Params)); |
| vos_mem_zero(&mac_ctx->lim.gLimOverlapNonGfParams, |
| sizeof(mac_ctx->lim.gLimOverlapNonGfParams)); |
| |
| old_op_mode = pe_session_entry->htOperMode; |
| pe_session_entry->htOperMode = eSIR_HT_OP_MODE_PURE; |
| mac_ctx->lim.gHTOperMode = eSIR_HT_OP_MODE_PURE; |
| |
| vos_mem_zero(&beacon_params, sizeof(tUpdateBeaconParams)); |
| /* index 0, is self node, peers start from 1 */ |
| for(i = 1 ; i <= mac_ctx->lim.gLimAssocStaLimit ; i++) |
| { |
| station_hash_node = dphGetHashEntry(mac_ctx, i, |
| &pe_session_entry->dph.dphHashTable); |
| if (NULL == station_hash_node) |
| continue; |
| limDecideApProtection(mac_ctx, station_hash_node->staAddr, |
| &beacon_params, pe_session_entry); |
| } |
| |
| if (pe_session_entry->htOperMode != old_op_mode) |
| bcn_prms_changed = true; |
| |
| if ((current_protection_state != pe_session_entry->old_protection_state) && |
| (VOS_FALSE == mac_ctx->sap.SapDfsInfo.is_dfs_cac_timer_running)) { |
| VOS_TRACE(VOS_MODULE_ID_PE, |
| VOS_TRACE_LEVEL_ERROR, |
| FL("protection changed, update beacon template")); |
| /* update beacon fix params and send update to FW */ |
| vos_mem_zero(&beacon_params, sizeof(tUpdateBeaconParams)); |
| beacon_params.bssIdx = pe_session_entry->bssIdx; |
| beacon_params.fShortPreamble = |
| pe_session_entry->beaconParams.fShortPreamble; |
| beacon_params.beaconInterval = |
| pe_session_entry->beaconParams.beaconInterval; |
| beacon_params.llaCoexist = |
| pe_session_entry->beaconParams.llaCoexist; |
| beacon_params.llbCoexist = |
| pe_session_entry->beaconParams.llbCoexist; |
| beacon_params.llgCoexist = |
| pe_session_entry->beaconParams.llgCoexist; |
| beacon_params.ht20MhzCoexist = |
| pe_session_entry->beaconParams.ht20Coexist; |
| beacon_params.llnNonGFCoexist = |
| pe_session_entry->beaconParams.llnNonGFCoexist; |
| beacon_params.fLsigTXOPProtectionFullSupport = |
| pe_session_entry->beaconParams.fLsigTXOPProtectionFullSupport; |
| beacon_params.fRIFSMode = |
| pe_session_entry->beaconParams.fRIFSMode; |
| beacon_params.smeSessionId = |
| pe_session_entry->smeSessionId; |
| beacon_params.paramChangeBitmap |= PARAM_llBCOEXIST_CHANGED; |
| bcn_prms_changed = true; |
| } |
| |
| if (bcn_prms_changed) { |
| schSetFixedBeaconFields(mac_ctx, pe_session_entry); |
| limSendBeaconParams(mac_ctx, &beacon_params, pe_session_entry); |
| } |
| |
| pe_session_entry->old_protection_state = current_protection_state; |
| if (VOS_STATUS_SUCCESS != vos_timer_start( |
| &pe_session_entry->protection_fields_reset_timer, |
| SCH_PROTECTION_RESET_TIME)) { |
| VOS_TRACE(VOS_MODULE_ID_PE, |
| VOS_TRACE_LEVEL_ERROR, |
| FL("cannot create or start protectionFieldsResetTimer")); |
| } |
| } |
| |
| #ifdef WLAN_FEATURE_FILS_SK |
| /** |
| * pe_delete_fils_info: API to delete fils session info |
| * @session: pe session |
| * |
| * Return: void |
| */ |
| void pe_delete_fils_info(tpPESession session) |
| { |
| struct pe_fils_session *fils_info; |
| |
| if (!session || (session && !session->valid)) { |
| VOS_TRACE(VOS_MODULE_ID_PE, VOS_TRACE_LEVEL_DEBUG, |
| FL("session is not valid")); |
| return; |
| } |
| fils_info = session->fils_info; |
| if (!fils_info) { |
| VOS_TRACE(VOS_MODULE_ID_PE, VOS_TRACE_LEVEL_DEBUG, |
| FL("fils info not found")); |
| return; |
| } |
| if (fils_info->keyname_nai_data) |
| vos_mem_free(fils_info->keyname_nai_data); |
| if (fils_info->fils_erp_reauth_pkt) |
| vos_mem_free(fils_info->fils_erp_reauth_pkt); |
| if (fils_info->fils_r_rk) |
| vos_mem_free(fils_info->fils_r_rk); |
| if (fils_info->fils_r_ik) |
| vos_mem_free(fils_info->fils_r_ik); |
| if (fils_info->fils_eap_finish_pkt) |
| vos_mem_free(fils_info->fils_eap_finish_pkt); |
| if (fils_info->fils_rmsk) |
| vos_mem_free(fils_info->fils_rmsk); |
| if (fils_info->fils_pmk) |
| vos_mem_free(fils_info->fils_pmk); |
| if (fils_info->auth_info.keyname) |
| vos_mem_free(fils_info->auth_info.keyname); |
| if (fils_info->auth_info.domain_name) |
| vos_mem_free(fils_info->auth_info.domain_name); |
| vos_mem_zero(fils_info->ick, MAX_ICK_LEN); |
| vos_mem_zero(fils_info->kek, MAX_KEK_LEN); |
| vos_mem_zero(fils_info->tk, MAX_TK_LEN); |
| vos_mem_zero(fils_info->key_auth, MAX_KEY_AUTH_DATA_LEN); |
| vos_mem_zero(fils_info->ap_key_auth_data, MAX_KEY_AUTH_DATA_LEN); |
| vos_mem_zero(fils_info->gtk, MAX_GTK_LEN); |
| vos_mem_zero(fils_info->igtk, MAX_IGTK_LEN); |
| vos_mem_zero(fils_info->ipn, IPN_LEN); |
| |
| vos_mem_free(fils_info); |
| session->fils_info = NULL; |
| } |
| /** |
| * pe_init_fils_info: API to initialize fils session info elements to null |
| * @session: pe session |
| * |
| * Return: void |
| */ |
| static void pe_init_fils_info(tpPESession session) |
| { |
| struct pe_fils_session *fils_info; |
| |
| if (!session || (session && !session->valid)) { |
| VOS_TRACE(VOS_MODULE_ID_PE, VOS_TRACE_LEVEL_DEBUG, |
| FL("session is not valid")); |
| return; |
| } |
| session->fils_info = vos_mem_malloc(sizeof(struct pe_fils_session)); |
| fils_info = session->fils_info; |
| if (!fils_info) { |
| VOS_TRACE(VOS_MODULE_ID_PE, VOS_TRACE_LEVEL_DEBUG, |
| FL("fils info not found")); |
| return; |
| } |
| |
| vos_mem_set(session->fils_info, sizeof(struct pe_fils_session), 0); |
| fils_info->keyname_nai_data = NULL; |
| fils_info->fils_erp_reauth_pkt = NULL; |
| fils_info->fils_r_rk = NULL; |
| fils_info->fils_r_ik = NULL; |
| fils_info->fils_eap_finish_pkt = NULL; |
| fils_info->fils_rmsk = NULL; |
| fils_info->fils_pmk = NULL; |
| fils_info->auth_info.keyname = NULL; |
| fils_info->auth_info.domain_name = NULL; |
| } |
| #else |
| static void pe_delete_fils_info(tpPESession session) { } |
| static void pe_init_fils_info(tpPESession session) { } |
| #endif |
| |
| /*-------------------------------------------------------------------------- |
| |
| \brief peCreateSession() - creates a new PE session given the BSSID |
| |
| This function returns the session context and the session ID if the session |
| corresponding to the passed BSSID is found in the PE session table. |
| |
| \param pMac - pointer to global adapter context |
| \param bssid - BSSID of the new session |
| \param sessionId - session ID is returned here, if session is created. |
| \param bssType - station or a |
| \return tpPESession - pointer to the session context or NULL if session |
| can not be created. |
| |
| \sa |
| |
| --------------------------------------------------------------------------*/ |
| tpPESession peCreateSession(tpAniSirGlobal pMac, |
| tANI_U8 *bssid, |
| tANI_U8* sessionId, |
| tANI_U16 numSta, |
| tSirBssType bssType) |
| { |
| VOS_STATUS status; |
| tANI_U8 i; |
| for(i =0; i < pMac->lim.maxBssId; i++) |
| { |
| /* Find first free room in session table */ |
| if(pMac->lim.gpSession[i].valid == FALSE) |
| { |
| vos_mem_set((void*)&pMac->lim.gpSession[i], sizeof(tPESession), 0); |
| |
| //Allocate space for Station Table for this session. |
| pMac->lim.gpSession[i].dph.dphHashTable.pHashTable = vos_mem_malloc( |
| sizeof(tpDphHashNode)* (numSta + 1)); |
| if ( NULL == pMac->lim.gpSession[i].dph.dphHashTable.pHashTable ) |
| { |
| limLog(pMac, LOGE, FL("memory allocate failed!")); |
| return NULL; |
| } |
| pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray = vos_mem_malloc( |
| sizeof(tDphHashNode) * (numSta + 1)); |
| if ( NULL == pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray ) |
| { |
| limLog(pMac, LOGE, FL("memory allocate failed!")); |
| vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pHashTable); |
| pMac->lim.gpSession[i].dph.dphHashTable.pHashTable = NULL; |
| return NULL; |
| } |
| |
| pMac->lim.gpSession[i].dph.dphHashTable.size = numSta + 1; |
| |
| dphHashTableClassInit(pMac, |
| &pMac->lim.gpSession[i].dph.dphHashTable); |
| |
| pMac->lim.gpSession[i].gpLimPeerIdxpool = vos_mem_malloc(sizeof( |
| *pMac->lim.gpSession[i].gpLimPeerIdxpool) * (numSta+1)); |
| if ( NULL == pMac->lim.gpSession[i].gpLimPeerIdxpool ) |
| { |
| PELOGE(limLog(pMac, LOGE, FL("memory allocate failed!"));) |
| vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pHashTable); |
| vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray); |
| pMac->lim.gpSession[i].dph.dphHashTable.pHashTable = NULL; |
| pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray = NULL; |
| return NULL; |
| } |
| vos_mem_set(pMac->lim.gpSession[i].gpLimPeerIdxpool, |
| sizeof(*pMac->lim.gpSession[i].gpLimPeerIdxpool) * (numSta+1), 0); |
| pMac->lim.gpSession[i].freePeerIdxHead = 0; |
| pMac->lim.gpSession[i].freePeerIdxTail = 0; |
| pMac->lim.gpSession[i].gLimNumOfCurrentSTAs = 0; |
| |
| /* Copy the BSSID to the session table */ |
| sirCopyMacAddr(pMac->lim.gpSession[i].bssId, bssid); |
| if (bssType == eSIR_MONITOR_MODE) |
| sirCopyMacAddr(pMac->lim.gpSession[i].selfMacAddr, bssid); |
| pMac->lim.gpSession[i].valid = TRUE; |
| |
| /* Initialize the SME and MLM states to IDLE */ |
| pMac->lim.gpSession[i].limMlmState = eLIM_MLM_IDLE_STATE; |
| pMac->lim.gpSession[i].limSmeState = eLIM_SME_IDLE_STATE; |
| pMac->lim.gpSession[i].limCurrentAuthType = eSIR_OPEN_SYSTEM; |
| peInitBeaconParams(pMac, &pMac->lim.gpSession[i]); |
| #ifdef WLAN_FEATURE_VOWIFI_11R |
| pMac->lim.gpSession[i].is11Rconnection = FALSE; |
| #endif |
| |
| #ifdef FEATURE_WLAN_ESE |
| pMac->lim.gpSession[i].isESEconnection = FALSE; |
| #endif |
| |
| #if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR) |
| pMac->lim.gpSession[i].isFastTransitionEnabled = FALSE; |
| #endif |
| #ifdef FEATURE_WLAN_LFR |
| pMac->lim.gpSession[i].isFastRoamIniFeatureEnabled = FALSE; |
| #endif |
| *sessionId = i; |
| |
| pMac->lim.gpSession[i].gLimPhyMode = WNI_CFG_PHY_MODE_11G; //TODO :Check with the team what should be default mode |
| /* Initialize CB mode variables when session is created */ |
| pMac->lim.gpSession[i].htSupportedChannelWidthSet = 0; |
| pMac->lim.gpSession[i].htRecommendedTxWidthSet = 0; |
| pMac->lim.gpSession[i].htSecondaryChannelOffset = 0; |
| #ifdef FEATURE_WLAN_TDLS |
| vos_mem_set(pMac->lim.gpSession[i].peerAIDBitmap, |
| sizeof(pMac->lim.gpSession[i].peerAIDBitmap), 0); |
| pMac->lim.gpSession[i].tdls_prohibited = false; |
| pMac->lim.gpSession[i].tdls_chan_swit_prohibited = false; |
| #endif |
| pMac->lim.gpSession[i].fWaitForProbeRsp = 0; |
| pMac->lim.gpSession[i].fIgnoreCapsChange = 0; |
| |
| VOS_TRACE(VOS_MODULE_ID_PE, VOS_TRACE_LEVEL_DEBUG, |
| "Create a new PE session (%d) with BSSID: " |
| MAC_ADDRESS_STR " Max No. of STA %d", |
| *sessionId, MAC_ADDR_ARRAY(bssid), numSta); |
| pMac->lim.gpSession[i].roaming_in_progress = false; |
| |
| /* Initialize PMM Ps Offload Module */ |
| if(pMac->psOffloadEnabled) |
| { |
| if(pmmPsOffloadOpen(pMac, &pMac->lim.gpSession[i]) |
| != eHAL_STATUS_SUCCESS) |
| { |
| limLog(pMac, LOGE, |
| FL("Failed to open ps offload for pe session %x"), i); |
| } |
| } |
| |
| if (eSIR_INFRA_AP_MODE == bssType || |
| eSIR_IBSS_MODE == bssType || |
| eSIR_BTAMP_AP_MODE == bssType) |
| { |
| pMac->lim.gpSession[i].pSchProbeRspTemplate = |
| vos_mem_malloc(SCH_MAX_PROBE_RESP_SIZE); |
| pMac->lim.gpSession[i].pSchBeaconFrameBegin = |
| vos_mem_malloc(SCH_MAX_BEACON_SIZE); |
| pMac->lim.gpSession[i].pSchBeaconFrameEnd = |
| vos_mem_malloc(SCH_MAX_BEACON_SIZE); |
| if ( (NULL == pMac->lim.gpSession[i].pSchProbeRspTemplate) |
| || (NULL == pMac->lim.gpSession[i].pSchBeaconFrameBegin) |
| || (NULL == pMac->lim.gpSession[i].pSchBeaconFrameEnd) ) |
| { |
| PELOGE(limLog(pMac, LOGE, FL("memory allocate failed!"));) |
| vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pHashTable); |
| vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray); |
| vos_mem_free(pMac->lim.gpSession[i].gpLimPeerIdxpool); |
| vos_mem_free(pMac->lim.gpSession[i].pSchProbeRspTemplate); |
| vos_mem_free(pMac->lim.gpSession[i].pSchBeaconFrameBegin); |
| vos_mem_free(pMac->lim.gpSession[i].pSchBeaconFrameEnd); |
| |
| pMac->lim.gpSession[i].dph.dphHashTable.pHashTable = NULL; |
| pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray = NULL; |
| pMac->lim.gpSession[i].gpLimPeerIdxpool = NULL; |
| pMac->lim.gpSession[i].pSchProbeRspTemplate = NULL; |
| pMac->lim.gpSession[i].pSchBeaconFrameBegin = NULL; |
| pMac->lim.gpSession[i].pSchBeaconFrameEnd = NULL; |
| return NULL; |
| } |
| } |
| |
| #if defined WLAN_FEATURE_VOWIFI_11R |
| if (eSIR_INFRASTRUCTURE_MODE == bssType) { |
| limFTOpen(pMac, &pMac->lim.gpSession[i]); |
| } |
| #endif |
| if (eSIR_MONITOR_MODE == bssType) |
| limFTOpen(pMac, &pMac->lim.gpSession[i]); |
| |
| if (eSIR_INFRA_AP_MODE == bssType) { |
| pMac->lim.gpSession[i].old_protection_state = 0; |
| pMac->lim.gpSession[i].mac_ctx = (void *)pMac; |
| status = vos_timer_init( |
| &pMac->lim.gpSession[i].protection_fields_reset_timer, |
| VOS_TIMER_TYPE_SW, pe_reset_protection_callback, |
| (void *)&pMac->lim.gpSession[i]); |
| if (status == VOS_STATUS_SUCCESS) { |
| status = vos_timer_start( |
| &pMac->lim.gpSession[i].protection_fields_reset_timer, |
| SCH_PROTECTION_RESET_TIME); |
| } |
| if (status != VOS_STATUS_SUCCESS) { |
| VOS_TRACE(VOS_MODULE_ID_PE, |
| VOS_TRACE_LEVEL_ERROR, |
| FL("cannot create or start protectionFieldsResetTimer")); |
| } |
| } |
| |
| pe_init_fils_info(&pMac->lim.gpSession[i]); |
| |
| return(&pMac->lim.gpSession[i]); |
| } |
| } |
| limLog(pMac, LOGE, |
| FL("Session can not be created.. Reached Max permitted sessions")); |
| return NULL; |
| } |
| |
| /*-------------------------------------------------------------------------- |
| \brief peFindSessionByBssid() - looks up the PE session given the BSSID. |
| |
| This function returns the session context and the session ID if the session |
| corresponding to the given BSSID is found in the PE session table. |
| |
| \param pMac - pointer to global adapter context |
| \param bssid - BSSID of the session |
| \param sessionId -session ID is returned here, if session is found. |
| |
| \return tpPESession - pointer to the session context or NULL if session is not found. |
| |
| \sa |
| --------------------------------------------------------------------------*/ |
| tpPESession peFindSessionByBssid(tpAniSirGlobal pMac, tANI_U8* bssid, tANI_U8* sessionId) |
| { |
| tANI_U8 i; |
| |
| for(i =0; i < pMac->lim.maxBssId; i++) |
| { |
| /* If BSSID matches return corresponding tables address*/ |
| if( (pMac->lim.gpSession[i].valid) && (sirCompareMacAddr(pMac->lim.gpSession[i].bssId, bssid))) |
| { |
| *sessionId = i; |
| return(&pMac->lim.gpSession[i]); |
| } |
| } |
| |
| limLog(pMac, LOG4, FL("Session lookup fails for BSSID:")); |
| limPrintMacAddr(pMac, bssid, LOG4); |
| return(NULL); |
| |
| } |
| |
| |
| /*-------------------------------------------------------------------------- |
| \brief peFindSessionByBssIdx() - looks up the PE session given the bssIdx. |
| |
| This function returns the session context if the session |
| corresponding to the given bssIdx is found in the PE session table. |
| \param pMac - pointer to global adapter context |
| \param bssIdx - bss index of the session |
| \return tpPESession - pointer to the session context or NULL if session is not found. |
| \sa |
| --------------------------------------------------------------------------*/ |
| tpPESession peFindSessionByBssIdx(tpAniSirGlobal pMac, tANI_U8 bssIdx) |
| { |
| tANI_U8 i; |
| for (i = 0; i < pMac->lim.maxBssId; i++) |
| { |
| /* If BSSID matches return corresponding tables address*/ |
| if ( (pMac->lim.gpSession[i].valid) && (pMac->lim.gpSession[i].bssIdx == bssIdx)) |
| { |
| return &pMac->lim.gpSession[i]; |
| } |
| } |
| limLog(pMac, LOG4, FL("Session lookup fails for bssIdx: %d"), bssIdx); |
| return NULL; |
| } |
| |
| /** |
| * pe_find_session_by_sme_session_id() - looks up the PE session for given sme |
| * session id |
| * @mac_ctx: pointer to global adapter context |
| * @sme_session_id: sme session id |
| * |
| * looks up the PE session for given sme session id |
| * |
| * Return: pe session entry for given sme session if found else NULL |
| */ |
| tpPESession pe_find_session_by_sme_session_id(tpAniSirGlobal mac_ctx, |
| tANI_U8 sme_session_id) |
| { |
| uint8_t i; |
| for (i = 0; i < mac_ctx->lim.maxBssId; i++) { |
| if ( (mac_ctx->lim.gpSession[i].valid) && |
| (mac_ctx->lim.gpSession[i].smeSessionId == |
| sme_session_id) ) { |
| return &mac_ctx->lim.gpSession[i]; |
| } |
| } |
| limLog(mac_ctx, LOG4, |
| FL("Session lookup fails for smeSessionID: %d"), |
| sme_session_id); |
| return NULL; |
| } |
| |
| /** |
| * pe_count_session_with_sme_session_id() - count PE sessions for given sme |
| * session id |
| * @mac_ctx: pointer to global adapter context |
| * @sme_session_id: sme session id |
| * |
| * count PE sessions for given sme session id |
| * |
| * Return: number of pe session entry for given sme session |
| */ |
| uint8_t pe_count_session_with_sme_session_id(tpAniSirGlobal mac_ctx, |
| uint8_t sme_session_id) |
| { |
| uint8_t i, count = 0; |
| for (i = 0; i < mac_ctx->lim.maxBssId; i++) { |
| if ((mac_ctx->lim.gpSession[i].valid) && |
| (mac_ctx->lim.gpSession[i].smeSessionId == |
| sme_session_id)) { |
| count++; |
| } |
| } |
| limLog(mac_ctx, LOG4, |
| FL("%d sessions found for smeSessionID: %d"), |
| count, sme_session_id); |
| return count; |
| } |
| |
| |
| /*-------------------------------------------------------------------------- |
| \brief peFindSessionBySessionId() - looks up the PE session given the session ID. |
| |
| This function returns the session context if the session |
| corresponding to the given session ID is found in the PE session table. |
| |
| \param pMac - pointer to global adapter context |
| \param sessionId -session ID for which session context needs to be looked up. |
| |
| \return tpPESession - pointer to the session context or NULL if session is not found. |
| |
| \sa |
| --------------------------------------------------------------------------*/ |
| tpPESession peFindSessionBySessionId(tpAniSirGlobal pMac, tANI_U8 sessionId) |
| { |
| if(sessionId >= pMac->lim.maxBssId) |
| { |
| limLog(pMac, LOGE, FL("Invalid sessionId: %d"), sessionId); |
| return(NULL); |
| } |
| if((pMac->lim.gpSession[sessionId].valid == TRUE)) |
| { |
| return(&pMac->lim.gpSession[sessionId]); |
| } |
| return(NULL); |
| |
| } |
| |
| |
| /*-------------------------------------------------------------------------- |
| \brief peFindSessionByStaId() - looks up the PE session given staid. |
| |
| This function returns the session context and the session ID if the session |
| corresponding to the given StaId is found in the PE session table. |
| |
| \param pMac - pointer to global adapter context |
| \param staid - StaId of the session |
| \param sessionId -session ID is returned here, if session is found. |
| |
| \return tpPESession - pointer to the session context or NULL if session is not found. |
| |
| \sa |
| --------------------------------------------------------------------------*/ |
| tpPESession peFindSessionByStaId(tpAniSirGlobal pMac, tANI_U8 staid, tANI_U8* sessionId) |
| { |
| tANI_U8 i, j; |
| |
| for(i =0; i < pMac->lim.maxBssId; i++) |
| { |
| if(pMac->lim.gpSession[i].valid) |
| { |
| for(j = 0; j < pMac->lim.gpSession[i].dph.dphHashTable.size; j++) |
| { |
| if((pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray[j].valid) && |
| (pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray[j].added) && |
| (staid == pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray[j].staIndex)) |
| { |
| *sessionId = i; |
| return(&pMac->lim.gpSession[i]); |
| } |
| } |
| } |
| } |
| |
| limLog(pMac, LOG4, FL("Session lookup fails for StaId: %d"), staid); |
| return(NULL); |
| } |
| |
| |
| |
| /*-------------------------------------------------------------------------- |
| \brief peDeleteSession() - deletes the PE session given the session ID. |
| |
| |
| \param pMac - pointer to global adapter context |
| \param sessionId -session ID of the session which needs to be deleted. |
| |
| \sa |
| --------------------------------------------------------------------------*/ |
| void peDeleteSession(tpAniSirGlobal pMac, tpPESession psessionEntry) |
| { |
| tANI_U16 i = 0; |
| tANI_U16 n; |
| TX_TIMER *timer_ptr; |
| |
| if (!psessionEntry->valid) { |
| limLog(pMac, LOG1, FL("peSession %d already deleted"), |
| psessionEntry->peSessionId); |
| return; |
| } |
| |
| VOS_TRACE(VOS_MODULE_ID_PE, VOS_TRACE_LEVEL_DEBUG, |
| "Trying to delete PE session %d Opmode %d BssIdx %d" |
| " BSSID: " MAC_ADDRESS_STR, psessionEntry->peSessionId, |
| psessionEntry->operMode, psessionEntry->bssIdx, |
| MAC_ADDR_ARRAY(psessionEntry->bssId)); |
| |
| for (n = 0; n < (pMac->lim.maxStation + 1); n++) |
| { |
| timer_ptr = &pMac->lim.limTimers.gpLimCnfWaitTimer[n]; |
| |
| if(psessionEntry->peSessionId == timer_ptr->sessionId) |
| { |
| if(VOS_TRUE == tx_timer_running(timer_ptr)) |
| { |
| tx_timer_deactivate(timer_ptr); |
| } |
| } |
| } |
| |
| if (LIM_IS_AP_ROLE(psessionEntry)) { |
| vos_timer_stop(&psessionEntry->protection_fields_reset_timer); |
| vos_timer_destroy(&psessionEntry->protection_fields_reset_timer); |
| } |
| |
| #if defined (WLAN_FEATURE_VOWIFI_11R) |
| /* Delete FT related information */ |
| limFTCleanup(pMac, psessionEntry); |
| #endif |
| |
| if (psessionEntry->pLimStartBssReq != NULL) |
| { |
| vos_mem_free( psessionEntry->pLimStartBssReq ); |
| psessionEntry->pLimStartBssReq = NULL; |
| } |
| |
| if (psessionEntry->pLimJoinReq != NULL) |
| { |
| vos_mem_free( psessionEntry->pLimJoinReq ); |
| psessionEntry->pLimJoinReq = NULL; |
| } |
| |
| if (psessionEntry->pLimReAssocReq != NULL) |
| { |
| vos_mem_free( psessionEntry->pLimReAssocReq ); |
| psessionEntry->pLimReAssocReq = NULL; |
| } |
| |
| if (psessionEntry->pLimMlmJoinReq != NULL) |
| { |
| vos_mem_free( psessionEntry->pLimMlmJoinReq ); |
| psessionEntry->pLimMlmJoinReq = NULL; |
| } |
| |
| if (psessionEntry->dph.dphHashTable.pHashTable != NULL) |
| { |
| vos_mem_free(psessionEntry->dph.dphHashTable.pHashTable); |
| psessionEntry->dph.dphHashTable.pHashTable = NULL; |
| } |
| |
| if (psessionEntry->dph.dphHashTable.pDphNodeArray != NULL) |
| { |
| vos_mem_free(psessionEntry->dph.dphHashTable.pDphNodeArray); |
| psessionEntry->dph.dphHashTable.pDphNodeArray = NULL; |
| } |
| |
| if (psessionEntry->gpLimPeerIdxpool != NULL) |
| { |
| vos_mem_free(psessionEntry->gpLimPeerIdxpool); |
| psessionEntry->gpLimPeerIdxpool = NULL; |
| } |
| |
| if (psessionEntry->beacon != NULL) |
| { |
| vos_mem_free( psessionEntry->beacon); |
| psessionEntry->beacon = NULL; |
| psessionEntry->bcnLen = 0; |
| } |
| |
| if (psessionEntry->assocReq != NULL) |
| { |
| vos_mem_free( psessionEntry->assocReq); |
| psessionEntry->assocReq = NULL; |
| psessionEntry->assocReqLen = 0; |
| } |
| |
| if (psessionEntry->assocRsp != NULL) |
| { |
| vos_mem_free( psessionEntry->assocRsp); |
| psessionEntry->assocRsp = NULL; |
| psessionEntry->assocRspLen = 0; |
| } |
| |
| |
| if (psessionEntry->parsedAssocReq != NULL) |
| { |
| /* Clean up the individual allocation first */ |
| for (i=0; i < psessionEntry->dph.dphHashTable.size; i++) |
| { |
| if ( psessionEntry->parsedAssocReq[i] != NULL ) |
| { |
| if( ((tpSirAssocReq)(psessionEntry->parsedAssocReq[i]))->assocReqFrame ) |
| { |
| vos_mem_free(((tpSirAssocReq) |
| (psessionEntry->parsedAssocReq[i]))->assocReqFrame); |
| ((tpSirAssocReq)(psessionEntry->parsedAssocReq[i]))->assocReqFrame = NULL; |
| ((tpSirAssocReq)(psessionEntry->parsedAssocReq[i]))->assocReqFrameLength = 0; |
| } |
| vos_mem_free(psessionEntry->parsedAssocReq[i]); |
| psessionEntry->parsedAssocReq[i] = NULL; |
| } |
| } |
| /* Clean up the whole block */ |
| vos_mem_free(psessionEntry->parsedAssocReq); |
| psessionEntry->parsedAssocReq = NULL; |
| } |
| if (NULL != psessionEntry->limAssocResponseData) |
| { |
| vos_mem_free( psessionEntry->limAssocResponseData); |
| psessionEntry->limAssocResponseData = NULL; |
| } |
| |
| #if defined (WLAN_FEATURE_VOWIFI_11R) || defined (FEATURE_WLAN_ESE) || defined(FEATURE_WLAN_LFR) |
| if (NULL != psessionEntry->pLimMlmReassocRetryReq) |
| { |
| vos_mem_free( psessionEntry->pLimMlmReassocRetryReq); |
| psessionEntry->pLimMlmReassocRetryReq = NULL; |
| } |
| #endif |
| |
| if (NULL != psessionEntry->pLimMlmReassocReq) |
| { |
| vos_mem_free( psessionEntry->pLimMlmReassocReq); |
| psessionEntry->pLimMlmReassocReq = NULL; |
| } |
| |
| #if defined(FEATURE_WLAN_ESE) && !defined(FEATURE_WLAN_ESE_UPLOAD) |
| limCleanupEseCtxt(pMac, psessionEntry); |
| #endif |
| |
| /* Initialize PMM Ps Offload Module */ |
| if(pMac->psOffloadEnabled) |
| { |
| if(pmmPsOffloadClose(pMac, psessionEntry) |
| != eHAL_STATUS_SUCCESS) |
| { |
| limLog(pMac, LOGW, |
| FL("Failed to close ps offload for pe session %x"), |
| psessionEntry->peSessionId); |
| } |
| } |
| |
| if (NULL != psessionEntry->pSchProbeRspTemplate) |
| { |
| vos_mem_free(psessionEntry->pSchProbeRspTemplate); |
| psessionEntry->pSchProbeRspTemplate = NULL; |
| } |
| |
| if (NULL != psessionEntry->pSchBeaconFrameBegin) |
| { |
| vos_mem_free(psessionEntry->pSchBeaconFrameBegin); |
| psessionEntry->pSchBeaconFrameBegin = NULL; |
| } |
| |
| if (NULL != psessionEntry->pSchBeaconFrameEnd) |
| { |
| vos_mem_free(psessionEntry->pSchBeaconFrameEnd); |
| psessionEntry->pSchBeaconFrameEnd = NULL; |
| } |
| |
| /* Must free the buffer before peSession invalid */ |
| if (NULL != psessionEntry->addIeParams.probeRespData_buff) |
| { |
| vos_mem_free(psessionEntry->addIeParams.probeRespData_buff); |
| psessionEntry->addIeParams.probeRespData_buff = NULL; |
| psessionEntry->addIeParams.probeRespDataLen = 0; |
| } |
| if (NULL != psessionEntry->addIeParams.assocRespData_buff) |
| { |
| vos_mem_free(psessionEntry->addIeParams.assocRespData_buff); |
| psessionEntry->addIeParams.assocRespData_buff = NULL; |
| psessionEntry->addIeParams.assocRespDataLen = 0; |
| } |
| if (NULL != psessionEntry->addIeParams.probeRespBCNData_buff) |
| { |
| vos_mem_free(psessionEntry->addIeParams.probeRespBCNData_buff); |
| psessionEntry->addIeParams.probeRespBCNData_buff = NULL; |
| psessionEntry->addIeParams.probeRespBCNDataLen = 0; |
| } |
| |
| #ifdef WLAN_FEATURE_11W |
| /* if PMF connection */ |
| if (psessionEntry->limRmfEnabled && LIM_IS_STA_ROLE(psessionEntry)) { |
| vos_timer_destroy(&psessionEntry->pmfComebackTimer); |
| } |
| #endif |
| |
| if (psessionEntry->access_policy_vendor_ie) |
| vos_mem_free(psessionEntry->access_policy_vendor_ie); |
| |
| psessionEntry->access_policy_vendor_ie = NULL; |
| |
| pe_delete_fils_info(psessionEntry); |
| |
| psessionEntry->valid = FALSE; |
| |
| if (LIM_IS_AP_ROLE(psessionEntry)) |
| lim_check_and_reset_protection_params(pMac); |
| |
| return; |
| } |
| |
| |
| /*-------------------------------------------------------------------------- |
| \brief peFindSessionByPeerSta() - looks up the PE session given the Station Address. |
| |
| This function returns the session context and the session ID if the session |
| corresponding to the given station address is found in the PE session table. |
| |
| \param pMac - pointer to global adapter context |
| \param sa - Peer STA Address of the session |
| \param sessionId -session ID is returned here, if session is found. |
| |
| \return tpPESession - pointer to the session context or NULL if session is not found. |
| |
| \sa |
| --------------------------------------------------------------------------*/ |
| |
| |
| tpPESession peFindSessionByPeerSta(tpAniSirGlobal pMac, tANI_U8* sa, tANI_U8* sessionId) |
| { |
| tANI_U8 i; |
| tpDphHashNode pSta; |
| tANI_U16 aid; |
| |
| for(i =0; i < pMac->lim.maxBssId; i++) |
| { |
| if( (pMac->lim.gpSession[i].valid)) |
| { |
| pSta = dphLookupHashEntry(pMac, sa, &aid, &pMac->lim.gpSession[i].dph.dphHashTable); |
| if (pSta != NULL) |
| { |
| *sessionId = i; |
| return &pMac->lim.gpSession[i]; |
| } |
| } |
| } |
| |
| limLog(pMac, LOG1, FL("Session lookup fails for Peer StaId:")); |
| limPrintMacAddr(pMac, sa, LOG1); |
| return NULL; |
| } |
| |
| /** |
| * pe_get_active_session_count() - function to return active pe session count |
| * |
| * @mac_ctx: pointer to global mac structure |
| * |
| * returns number of active pe session count |
| * |
| * Return: 0 if there are no active sessions else return number of active |
| * sessions |
| */ |
| int pe_get_active_session_count(tpAniSirGlobal mac_ctx) |
| { |
| int i, active_session_count = 0; |
| |
| for (i = 0; i < mac_ctx->lim.maxBssId; i++) |
| if (mac_ctx->lim.gpSession[i].valid) |
| active_session_count++; |
| |
| return active_session_count; |
| } |
