/* * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * Neither the name of The Linux Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "aniGlobal.h" #include "limTypes.h" #include "limUtils.h" #include "limFT.h" #include "limSendMessages.h" #include "limAssocUtils.h" #include "limSerDesUtils.h" #include "limSmeReqUtils.h" #include "limAdmitControl.h" #include "sirApi.h" #include "rrmApi.h" #include "wlan_qct_tl.h" #define PREAUTH_REASSOC_TIMEOUT 500 void lim_cleanup_connected_ap(tpAniSirGlobal mac, tpDphHashNode sta_ds, tpPESession session_entry); /** * lim_post_pre_auth_reassoc_rsp() -Posts preauth_reassoc response to SME * @mac: MAC context * @status: status * @session_entry: session entry * @reason: indicates which type of clean up needs to be performed * * This function process preauth_reassoc response to SME */ void lim_post_pre_auth_reassoc_rsp(tpAniSirGlobal mac, tSirRetStatus status, tpPESession session_entry, enum sir_roam_cleanup_type reason) { tpSirFTPreAuthRsp pre_auth_rsp; tSirMsgQ mmh_msg; tANI_U16 rsp_len = sizeof(tSirFTPreAuthRsp); tpPESession session_entry_con_ap; tpDphHashNode sta_ds = NULL; if (session_entry == NULL) { limLog(mac, LOGE, FL("Invalid Session Entry")); return; } pre_auth_rsp = (tpSirFTPreAuthRsp)vos_mem_malloc(rsp_len); if (NULL == pre_auth_rsp) { limLog(mac, LOGE, FL("Failed to allocate memory")); return; } limLog(mac, LOG1, FL("reason %d"), reason); vos_mem_zero(pre_auth_rsp, rsp_len); pre_auth_rsp->messageType = eWNI_SME_MBB_PRE_AUTH_REASSOC_RSP; pre_auth_rsp->length = (tANI_U16)rsp_len; pre_auth_rsp->status = status; pre_auth_rsp->reason = reason; pre_auth_rsp->smeSessionId = session_entry->smeSessionId; /* The bssid of the AP we are sending Auth1 to. */ if (mac->ft.ftPEContext.pFTPreAuthReq) sirCopyMacAddr(pre_auth_rsp->preAuthbssId, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId); if (status != eSIR_SUCCESS) { limLog(mac, LOG1, FL("Pre-Auth Failed, Cleanup!")); limLog(mac, LOG1, FL("flushing cached packets")); WLANTL_PreAssocForward(false); /* * If reason is full clean up, add sme session id that * will be useful in CSR during cleanup. */ if (reason == SIR_MBB_DISCONNECTED) { session_entry_con_ap = (tpPESession)mac->ft.ftPEContext.psavedsessionEntry; pre_auth_rsp->smeSessionId = session_entry_con_ap->smeSessionId; } limFTCleanup(mac); } if (status == eSIR_SUCCESS) { limLog(mac, LOG1, FL("Success")); rsp_len = session_entry->assocReqLen + session_entry->assocRspLen + session_entry->bcnLen; pre_auth_rsp->roam_info = vos_mem_malloc(sizeof(tCsrRoamInfo)); if (pre_auth_rsp->roam_info == NULL) { limLog(mac, LOGE, FL("Failed to allocate memory for roam info")); return; } vos_mem_set(pre_auth_rsp->roam_info, sizeof(tCsrRoamInfo), 0); pre_auth_rsp->roam_info->pbFrames = vos_mem_malloc(rsp_len); if (pre_auth_rsp->roam_info->pbFrames == NULL) { limLog(mac, LOGE, FL("Failed to allocate memory for roam info frames")); return; } vos_mem_set(pre_auth_rsp->roam_info->pbFrames, rsp_len, 0); pre_auth_rsp->length += rsp_len + sizeof(tCsrRoamInfo); session_entry_con_ap = (tpPESession)mac->ft.ftPEContext.psavedsessionEntry; pre_auth_rsp->smeSessionId = session_entry_con_ap->smeSessionId; if(session_entry->beacon != NULL) { pre_auth_rsp->roam_info->nBeaconLength = session_entry->bcnLen; vos_mem_copy(pre_auth_rsp->roam_info->pbFrames, session_entry->beacon, session_entry->bcnLen); limLog(mac, LOG1, FL("Beacon len %d"), session_entry->bcnLen); vos_mem_free(session_entry->beacon); session_entry->beacon = NULL; } if(session_entry->assocReq != NULL) { pre_auth_rsp->roam_info->nAssocReqLength = session_entry->assocReqLen; vos_mem_copy(pre_auth_rsp->roam_info->pbFrames + session_entry->bcnLen, session_entry->assocReq, session_entry->assocReqLen); vos_mem_free(session_entry->assocReq); session_entry->assocReq = NULL; limLog(mac, LOG1, FL("AssocReq len %d"), session_entry->assocReqLen); } if(session_entry->assocRsp != NULL) { pre_auth_rsp->roam_info->nAssocRspLength = session_entry->assocRspLen; vos_mem_copy(pre_auth_rsp->roam_info->pbFrames + session_entry->bcnLen + session_entry->assocReqLen, session_entry->assocRsp, session_entry->assocRspLen); vos_mem_free(session_entry->assocRsp); session_entry->assocRsp = NULL; limLog(mac, LOG1, FL("AssocRsp len %d"), session_entry->assocRspLen); } sta_ds = dphGetHashEntry(mac, DPH_STA_HASH_INDEX_PEER, &session_entry->dph.dphHashTable); if(NULL == sta_ds) { limLog(mac, LOGE, FL("Unable to get the DPH Hash Entry for AID - %d"), DPH_STA_HASH_INDEX_PEER); return; } pre_auth_rsp->roam_info->staId = sta_ds->staIndex; pre_auth_rsp->roam_info->ucastSig = sta_ds->ucUcastSig; pre_auth_rsp->roam_info->bcastSig = sta_ds->ucBcastSig; pre_auth_rsp->roam_info->maxRateFlags = limGetMaxRateFlags(sta_ds, session_entry); } mmh_msg.type = pre_auth_rsp->messageType; mmh_msg.bodyptr = pre_auth_rsp; mmh_msg.bodyval = 0; limLog(mac, LOG1, FL("Posted Auth Rsp to SME with status of 0x%x"), status); limSysProcessMmhMsgApi(mac, &mmh_msg, ePROT); } /* * lim_reassoc_fail_cleanup() -handles cleanup during reassoc failure * @mac: MAC context * @status: status * @data: pointer to data * * This function handles cleanup during reassoc failure */ void lim_reassoc_fail_cleanup(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data) { tpPESession session_entry; session_entry = (tpPESession)data; if (!mac->ft.ftPEContext.pFTPreAuthReq) { limLog(mac, LOGE, FL("pFTPreAuthReq is NULL")); return; } if (dphDeleteHashEntry(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, DPH_STA_HASH_INDEX_PEER, &session_entry->dph.dphHashTable) != eSIR_SUCCESS) { limLog(mac, LOGE, FL("error deleting hash entry")); } /* Delete session as session was created during preauth success */ peDeleteSession(mac, session_entry); /* Add bss parameter cleanup happens as part of this processing*/ if ((status == eHAL_STATUS_MBB_DEL_BSS_FAIL) || (status == eHAL_STATUS_INVALID_PARAMETER) || (status == eHAL_STATUS_MBB_ADD_BSS_FAIL)) lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_DISCONNECTED); else lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); } /* * lim_perform_post_reassoc_mbb_channel_change() -invokes resume callback * @mac: MAC context * @status: status * @data: pointer to data * @session_entry: session entry * * This function invokes resume callback */ void lim_perform_post_reassoc_mbb_channel_change(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data, tpPESession session_entry) { tpPESession session_entry_con_ap; tANI_U8 session_id; session_entry_con_ap = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->currbssId, &session_id); if (session_entry_con_ap == NULL) { limLog(mac, LOGE, FL("session does not exist for given BSSID" MAC_ADDRESS_STR), MAC_ADDR_ARRAY(mac->ft.ftPEContext.pFTPreAuthReq->currbssId)); lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); return; } peSetResumeChannel(mac, session_entry_con_ap->currentOperChannel, 0); limResumeLink(mac, lim_reassoc_fail_cleanup, (tANI_U32 *)session_entry); } /* * lim_handle_reassoc_mbb_fail() -handles reassoc failure * @mac: MAC context * @session_entry: session entry * * This function handles reassoc failure */ void lim_handle_reassoc_mbb_fail(tpAniSirGlobal mac, tpPESession session_entry) { tpPESession session_entry_con_ap; tANI_U8 session_id; session_entry_con_ap = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->currbssId, &session_id); if (session_entry_con_ap == NULL) { limLog(mac, LOGE, FL("session does not exist for given BSSID" MAC_ADDRESS_STR), MAC_ADDR_ARRAY(mac->ft.ftPEContext.pFTPreAuthReq->currbssId)); lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); return; } limLog(mac, LOG1, FL("currentOperChannel %d preAuthchannelNum %d"), session_entry_con_ap->currentOperChannel, mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum); /* Restore set link to post assoc for currently connected AP */ if (limSetLinkState(mac, eSIR_LINK_POSTASSOC_STATE, session_entry_con_ap->bssId, session_entry_con_ap->selfMacAddr, NULL, NULL) != eSIR_SUCCESS) { limLog(mac, LOGE, FL("Set link state to POSTASSOC failed")); lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); return; } /* Change channel if required as channel might be changed during preauth */ if (session_entry_con_ap->currentOperChannel != mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum) { limChangeChannelWithCallback(mac, session_entry_con_ap->currentOperChannel, lim_perform_post_reassoc_mbb_channel_change, NULL, session_entry); } else { /* * Link needs to be resumed as link was suspended * for same channel during preauth. */ peSetResumeChannel(mac, session_entry_con_ap->currentOperChannel, 0); limResumeLink(mac, lim_reassoc_fail_cleanup, (tANI_U32 *)session_entry); } } /* * lim_preauth_fail_cleanup() -handles cleanup during preauth failure * @mac: MAC context * @status: status * @data: pointer to data * * This function handles cleanup during reassoc failure */ void lim_preauth_fail_cleanup(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data) { tpPESession session_entry; session_entry = (tpPESession)data; lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); } /* * lim_perform_preauth_mbb_fail_channel_change() -invokes resume callback * @mac: MAC context * @status: status * @data: pointer to data * @session_entry: session entry * * This function invokes resume callback */ void lim_perform_preauth_mbb_fail_channel_change(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data, tpPESession session_entry) { peSetResumeChannel(mac, session_entry->currentOperChannel, 0); limResumeLink(mac, lim_preauth_fail_cleanup, (tANI_U32 *)session_entry); } /* * lim_handle_preauth_mbb_fail() -handles preauth failure * @mac: MAC context * @session_entry: session entry * * This function handles reassoc failure */ void lim_handle_preauth_mbb_fail(tpAniSirGlobal mac, tpPESession session_entry) { limLog(mac, LOG1, FL("currentOperChannel %d preAuthchannelNum %d"), session_entry->currentOperChannel, mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum); /* Restore set link to post assoc for currently connected AP */ if (limSetLinkState(mac, eSIR_LINK_POSTASSOC_STATE, session_entry->bssId, session_entry->selfMacAddr, NULL, NULL) != eSIR_SUCCESS) { limLog(mac, LOGE, FL("Set link state to POSTASSOC failed")); lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); return; } /* Change channel if required as channel might be changed during preauth */ if (session_entry->currentOperChannel != mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum) { limChangeChannelWithCallback(mac, session_entry->currentOperChannel, lim_perform_preauth_mbb_fail_channel_change, NULL, session_entry); } else { /* * Link needs to be resumed as link was suspended * for same channel during preauth. */ peSetResumeChannel(mac, session_entry->currentOperChannel, 0); limResumeLink(mac, lim_preauth_fail_cleanup, (tANI_U32 *)session_entry); } } /* * lim_del_sta_mbb() -performs del sta * @mac: MAC context * @sta_ds_connected_ap: station entry of connected AP * @resp_reqd: indicates whether response is required or not * @session_entry_connected_ap: session entry of connected AP * * This function performs del sta */ tSirRetStatus lim_del_sta_mbb(tpAniSirGlobal mac, tpDphHashNode sta_ds_connected_ap, tANI_BOOLEAN resp_reqd, tpPESession session_entry_connected_ap) { tpDeleteStaParams del_sta_params; tSirMsgQ msg; tSirRetStatus ret_code; del_sta_params = vos_mem_malloc(sizeof(*del_sta_params)); if (NULL == del_sta_params) { limLog(mac, LOGE, FL("Unable to allocate memory during DEL_STA" )); return eSIR_MEM_ALLOC_FAILED; } vos_mem_zero(del_sta_params, sizeof(*del_sta_params)); del_sta_params->sessionId = session_entry_connected_ap->peSessionId; del_sta_params->status = eHAL_STATUS_SUCCESS; #ifdef FEATURE_WLAN_TDLS if(((eLIM_STA_ROLE == GET_LIM_SYSTEM_ROLE(session_entry_connected_ap)) && (sta_ds_connected_ap->staType != STA_ENTRY_TDLS_PEER)) || (eLIM_BT_AMP_STA_ROLE == GET_LIM_SYSTEM_ROLE(session_entry_connected_ap))) #else if((eLIM_STA_ROLE == GET_LIM_SYSTEM_ROLE(session_entry_connected_ap)) || (eLIM_BT_AMP_STA_ROLE == GET_LIM_SYSTEM_ROLE(session_entry_connected_ap))) #endif del_sta_params->staIdx = session_entry_connected_ap->staId; else del_sta_params->staIdx = sta_ds_connected_ap->staIndex; del_sta_params->assocId = sta_ds_connected_ap->assocId; del_sta_params->respReqd = resp_reqd; /* Change Mlm state of connected AP to Del sta rsp state */ session_entry_connected_ap->limMlmState = eLIM_MLM_WT_DEL_STA_RSP_STATE; MTRACE(macTrace(mac, TRACE_CODE_MLM_STATE, session_entry_connected_ap->peSessionId, eLIM_MLM_WT_DEL_STA_RSP_STATE)); msg.type = WDA_DELETE_STA_REQ; msg.reserved = 0; msg.bodyptr = del_sta_params; msg.bodyval = 0; limLog(mac, LOG1, FL("sessionId %d staIdx: %d assocId: %d for "MAC_ADDRESS_STR), del_sta_params->sessionId, del_sta_params->staIdx, del_sta_params->assocId, MAC_ADDR_ARRAY(sta_ds_connected_ap->staAddr)); MTRACE(macTraceMsgTx(mac, session_entry_connected_ap->peSessionId, msg.type)); ret_code = wdaPostCtrlMsg(mac, &msg); if( eSIR_SUCCESS != ret_code) { if(resp_reqd) SET_LIM_PROCESS_DEFD_MESGS(mac, true); limLog(mac, LOGE, FL("Posting DELETE_STA_REQ failed, reason=%X"), ret_code); vos_mem_free(del_sta_params); } return ret_code; } /* * lim_del_bss_mbb() -performs del bss of connected AP * @mac: MAC context * @sta_ds: station entry * @bss_idx:BSS index * @session_entry: session entry * * This function performs del bss of connected AP */ tSirRetStatus lim_del_bss_mbb(tpAniSirGlobal mac, tpDphHashNode sta_ds, tANI_U16 bss_idx,tpPESession session_entry) { tpDeleteBssParams delbss_params = NULL; tSirMsgQ msg; tSirRetStatus ret_code = eSIR_SUCCESS; delbss_params = vos_mem_malloc(sizeof(tDeleteBssParams)); if (NULL == delbss_params) { limLog(mac, LOGE, FL("Unable to allocate memory during del bss" )); return eSIR_MEM_ALLOC_FAILED; } vos_mem_set((tANI_U8 *) delbss_params, sizeof(tDeleteBssParams), 0); delbss_params->sessionId = session_entry->peSessionId; if (sta_ds != NULL) { delbss_params->bssIdx = sta_ds->bssId; sta_ds->valid = 0; sta_ds->mlmStaContext.mlmState = eLIM_MLM_WT_DEL_BSS_RSP_STATE; } else delbss_params->bssIdx = bss_idx; session_entry->limMlmState = eLIM_MLM_WT_DEL_BSS_RSP_STATE; MTRACE(macTrace(mac, TRACE_CODE_MLM_STATE, session_entry->peSessionId, eLIM_MLM_WT_DEL_BSS_RSP_STATE)); delbss_params->status= eHAL_STATUS_SUCCESS; delbss_params->respReqd = 1; limLog(mac, LOG1, FL("Sessionid %d bss idx: %x BSSID:" MAC_ADDRESS_STR), delbss_params->sessionId, delbss_params->bssIdx, MAC_ADDR_ARRAY(session_entry->bssId)); /* we need to defer the message until we get the response back from HAL. */ SET_LIM_PROCESS_DEFD_MESGS(mac, false); msg.type = WDA_DELETE_BSS_REQ; msg.reserved = 0; msg.bodyptr = delbss_params; msg.bodyval = 0; MTRACE(macTraceMsgTx(mac, session_entry->peSessionId, msg.type)); if(eSIR_SUCCESS != (ret_code = wdaPostCtrlMsg(mac, &msg))) { SET_LIM_PROCESS_DEFD_MESGS(mac, true); limLog(mac, LOGE, FL("Posting DELETE_BSS_REQ to HAL failed, reason=%X"), ret_code); vos_mem_free(delbss_params); } return ret_code; } /* * lim_add_bss_mbb() -performs add bss of new roamable AP * @mac: MAC context * @sta_ds: station entry * @bss_idx:BSS index * @session_entry: session entry * * This function performs add bss of new roamable AP */ void lim_add_bss_mbb(tpAniSirGlobal mac, tpDphHashNode sta_ds, tpPESession session_entry) { tSirMsgQ msg; tSirRetStatus ret_code; /* we need to defer the message until we get the response back from HAL. */ SET_LIM_PROCESS_DEFD_MESGS(mac, false); msg.type = SIR_HAL_ADD_BSS_REQ; msg.reserved = 0; msg.bodyptr = mac->ft.ftPEContext.pAddBssReq; msg.bodyval = 0; limLog(mac, LOG1, FL("Sending SIR_HAL_ADD_BSS_REQ")); session_entry->limMlmState = eLIM_MLM_WT_ADD_BSS_RSP_REASSOC_STATE; MTRACE(macTrace(mac, TRACE_CODE_MLM_STATE, session_entry->peSessionId, eLIM_MLM_WT_ADD_BSS_RSP_REASSOC_STATE)); MTRACE(macTraceMsgTx(mac, session_entry->peSessionId, msg.type)); ret_code = wdaPostCtrlMsg(mac, &msg); if( eSIR_SUCCESS != ret_code) { vos_mem_free(mac->ft.ftPEContext.pAddBssReq); limLog(mac, LOGE, FL("Posting ADD_BSS_REQ to HAL failed, reason=%X"), ret_code); } /* Dont need this anymore */ mac->ft.ftPEContext.pAddBssReq = NULL; } tSirRetStatus lim_add_sta_mbb(tpAniSirGlobal mac, tANI_U16 assoc_id, tpPESession session_entry) { tpAddStaParams add_sta_params = NULL; tSirMsgQ msg; tSirRetStatus retCode = eSIR_SUCCESS; add_sta_params = mac->ft.ftPEContext.pAddStaReq; add_sta_params->assocId = assoc_id; msg.type = SIR_HAL_ADD_STA_REQ; msg.reserved = 0; msg.bodyptr = add_sta_params; msg.bodyval = 0; limLog(mac, LOG1, FL("Sending SIR_HAL_ADD_STA_REQ. aid %d)"), add_sta_params->assocId); session_entry->limPrevMlmState = session_entry->limMlmState; session_entry->limMlmState = eLIM_MLM_WT_ADD_STA_RSP_STATE; MTRACE(macTrace(mac, TRACE_CODE_MLM_STATE, session_entry->peSessionId, eLIM_MLM_WT_ADD_STA_RSP_STATE)); MTRACE(macTraceMsgTx(mac, session_entry->peSessionId, msg.type)); if(eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( mac, &msg))) { limLog(mac, LOGE, FL("Posting ADD_STA_REQ to HAL failed, reason=%X"), retCode); vos_mem_free(add_sta_params); } mac->ft.ftPEContext.pAddStaReq = NULL; return retCode; } /* * lim_handle_reassoc_mbb_success() -handles reassoc success * @mac: MAC context * @session_entry: session entry * @assoc_rsp: pointer to assoc response * @sta_ds : station entry * * This function handles reassoc success */ void lim_handle_reassoc_mbb_success(tpAniSirGlobal mac, tpPESession session_entry, tpSirAssocRsp assoc_rsp, tpDphHashNode sta_ds) { tpPESession session_entry_con_ap; tANI_U8 session_id_connected_ap; tpDphHashNode sta_ds_connected_ap; tANI_U16 aid; tSirRetStatus ret_code; limUpdateAssocStaDatas(mac, sta_ds, assoc_rsp, session_entry); /* Store assigned AID for TIM processing */ session_entry->limAID = assoc_rsp->aid & 0x3FFF; /* De register STA for currently connected AP */ mac->sme.roaming_mbb_callback(mac, mac->ft.ftSmeContext.smeSessionId, NULL, NULL, SIR_ROAMING_DEREGISTER_STA); mac->sme.roaming_mbb_callback(mac, mac->ft.ftSmeContext.smeSessionId, NULL, NULL, SIR_STOP_ROAM_OFFLOAD_SCAN); if((session_entry_con_ap = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->currbssId, &session_id_connected_ap))== NULL) { limLog(mac, LOGE, FL("session does not exist for given BSSID" MAC_ADDRESS_STR), MAC_ADDR_ARRAY(mac->ft.ftPEContext.pFTPreAuthReq->currbssId)); goto cleanup; } session_entry->smeSessionId = session_entry_con_ap->smeSessionId; sta_ds_connected_ap = dphLookupHashEntry(mac, mac->ft.ftPEContext.pFTPreAuthReq->currbssId, &aid, &session_entry_con_ap->dph.dphHashTable); if (sta_ds_connected_ap == NULL) { limLog(mac, LOGE, FL("sta_ds NULL for given BSSID" MAC_ADDRESS_STR), MAC_ADDR_ARRAY(mac->ft.ftPEContext.pFTPreAuthReq->currbssId)); goto cleanup; } /* * Change Mlm state of new AP to Del sta rsp state so that * duplicate reassoc response will be dropped. */ session_entry->limMlmState = eLIM_MLM_WT_DEL_STA_RSP_STATE; MTRACE(macTrace(mac, TRACE_CODE_MLM_STATE, session_entry->peSessionId, eLIM_MLM_WT_DEL_STA_RSP_STATE)); /* Delete sta for currently connected AP */ ret_code = lim_del_sta_mbb(mac, sta_ds_connected_ap, false, session_entry_con_ap); if (ret_code == eSIR_SUCCESS) return; /* Connected AP lim cleanup.*/ lim_cleanup_connected_ap(mac, sta_ds_connected_ap, session_entry_con_ap); cleanup: /* * eHAL_STATUS_INVALID_PARAMETER is used * so that full cleanup is triggered. */ lim_reassoc_fail_cleanup(mac, eHAL_STATUS_INVALID_PARAMETER, (tANI_U32 *)session_entry); } /* * lim_process_preauth_mbb_result() -process pre auth result * @mac: MAC context * @status: status * @data: pointer to data * * This function invokes resume callback */ static inline void lim_process_preauth_mbb_result(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data) { tpPESession session_entry, ft_session_entry = NULL; tpDphHashNode sta_ds; tAddBssParams *add_bss_params; tSirSmeJoinReq *reassoc_req; tLimMlmReassocReq *mlm_reassoc_req; tANI_U16 caps; tANI_U16 nSize; tpSirSmeJoinReq pReassocReq = NULL; if (!mac->ft.ftPEContext.pFTPreAuthReq) { limLog(mac, LOG1, "Pre-Auth request is NULL!"); goto end; } session_entry = (tpPESession)data; /* Post the FT Pre Auth Response to SME in case of failure*/ if (mac->ft.ftPEContext.ftPreAuthStatus == eSIR_FAILURE) goto end; /* Flow for preauth success */ limFTSetupAuthSession(mac, session_entry); /* * Prepare reassoc request. Memory allocated for tSirSmeJoinReq *reassoc_req in csr_fill_reassoc_req. Free that memory here. */ mac->sme.roaming_mbb_callback(mac, mac->ft.ftSmeContext.smeSessionId, mac->ft.ftPEContext.pFTPreAuthReq->pbssDescription, &reassoc_req, SIR_PREPARE_REASSOC_REQ); if (reassoc_req == NULL) { limLog(mac, LOGE, FL("reassoc req is NULL")); goto end; } nSize = __limGetSmeJoinReqSizeForAlloc((tANI_U8 *) reassoc_req); pReassocReq = vos_mem_malloc(nSize); if ( NULL == pReassocReq ) { limLog(mac, LOGE, FL("call to AllocateMemory failed for pReassocReq")); vos_mem_free(reassoc_req); goto end; } vos_mem_set((void *) pReassocReq, nSize, 0); if ((limJoinReqSerDes(mac, (tpSirSmeJoinReq) pReassocReq, (tANI_U8 *) reassoc_req) == eSIR_FAILURE) || (!limIsSmeJoinReqValid(mac, (tpSirSmeJoinReq) pReassocReq))) { limLog(mac, LOGE, FL("received SME_REASSOC_REQ with invalid data")); vos_mem_free(reassoc_req); goto end; } ft_session_entry = mac->ft.ftPEContext.pftSessionEntry; ft_session_entry->pLimReAssocReq = pReassocReq; add_bss_params = mac->ft.ftPEContext.pAddBssReq; mlm_reassoc_req = vos_mem_malloc(sizeof(tLimMlmReassocReq)); if (NULL == mlm_reassoc_req) { limLog(mac, LOGE, FL("call to AllocateMemory failed for mlmReassocReq")); vos_mem_free(reassoc_req); goto end; } vos_mem_copy(mlm_reassoc_req->peerMacAddr, ft_session_entry->limReAssocbssId, sizeof(tSirMacAddr)); mlm_reassoc_req->reassocFailureTimeout = PREAUTH_REASSOC_TIMEOUT; if (cfgGetCapabilityInfo(mac, &caps, ft_session_entry) != eSIR_SUCCESS) { limLog(mac, LOGE, FL("could not retrieve Capabilities value")); vos_mem_free(mlm_reassoc_req); vos_mem_free(reassoc_req); goto end; } lim_update_caps_info_for_bss(mac, &caps, reassoc_req->bssDescription.capabilityInfo); vos_mem_free(reassoc_req); limLog(mac, LOG1, FL("Capabilities info Reassoc: 0x%X"), caps); mlm_reassoc_req->capabilityInfo = caps; mlm_reassoc_req->sessionId = ft_session_entry->peSessionId; mlm_reassoc_req->listenInterval = WNI_CFG_LISTEN_INTERVAL_STADEF; if ((sta_ds = dphAddHashEntry(mac, add_bss_params->bssId, DPH_STA_HASH_INDEX_PEER, &ft_session_entry->dph.dphHashTable)) == NULL) { limLog(mac, LOGE, FL("could not add hash entry at DPH")); limPrintMacAddr(mac, add_bss_params->bssId, LOGE); vos_mem_free(mlm_reassoc_req); goto end; } /* Start timer here to handle reassoc timeout */ mac->lim.limTimers.glim_reassoc_mbb_rsp_timer.sessionId = ft_session_entry->peSessionId; MTRACE(macTrace(mac, TRACE_CODE_TIMER_ACTIVATE, session_entry->peSessionId, eLIM_REASSOC_MBB_RSP_TIMER)); if(TX_SUCCESS != tx_timer_activate(&mac->lim.limTimers.glim_reassoc_mbb_rsp_timer)) { limLog(mac, LOGE, FL("Reassoc MBB Rsp Timer Start Failed")); if (ft_session_entry->pLimReAssocReq) { vos_mem_free(ft_session_entry->pLimReAssocReq); ft_session_entry->pLimReAssocReq = NULL; } vos_mem_free(mlm_reassoc_req); goto end; } limLog(mac, LOG1, FL("enabling caching")); WLANTL_EnablePreAssocCaching(); /* To do: Add changes for reassoc fail timer */ limSendReassocReqWithFTIEsMgmtFrame(mac, mlm_reassoc_req, ft_session_entry); ft_session_entry->limMlmState = eLIM_MLM_WT_REASSOC_RSP_STATE; limLog(mac, LOG1, FL("Set the mlm state to %d session=%d"), ft_session_entry->limMlmState, ft_session_entry->peSessionId); return; end: if (ft_session_entry) lim_handle_reassoc_mbb_fail(mac, ft_session_entry); } /* * lim_perform_post_preauth_mbb_channel_change() -invokes resume callback * @mac: MAC context * @status: status * @data: pointer to data * @session_entry: session entry * * This function invokes resume callback after successful reception of * pre auth */ static inline void lim_perform_post_preauth_mbb_channel_change(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data, tpPESession session_entry) { peSetResumeChannel(mac, 0, 0); limResumeLink(mac, lim_process_preauth_mbb_result, (tANI_U32 *)session_entry); } /* * lim_handle_pre_auth_mbb_rsp() -handles preauth response * @mac: MAC context * @status: status of message * @session_entry: session entry * * This function process preauth response */ void lim_handle_pre_auth_mbb_rsp(tpAniSirGlobal mac, tSirRetStatus status, tpPESession session_entry) { tpPESession ft_session_entry; tANI_U8 session_id; tpSirBssDescription bss_description; mac->ft.ftPEContext.ftPreAuthStatus = status; mac->ft.ftPEContext.saved_auth_rsp_length = 0; limLog(mac, LOG1, FL("preauth status %d"), mac->ft.ftPEContext.ftPreAuthStatus); /* Create FT session for the re-association at this point */ if (mac->ft.ftPEContext.ftPreAuthStatus == eSIR_SUCCESS) { bss_description = mac->ft.ftPEContext.pFTPreAuthReq->pbssDescription; if((ft_session_entry = peCreateSession(mac, bss_description->bssId, &session_id, mac->lim.maxStation)) == NULL) { limLog(mac, LOGE, FL("session can not be created for pre-auth AP")); mac->ft.ftPEContext.ftPreAuthStatus = eSIR_FAILURE; goto out; } ft_session_entry->peSessionId = session_id; sirCopyMacAddr(ft_session_entry->selfMacAddr, session_entry->selfMacAddr); sirCopyMacAddr(ft_session_entry->limReAssocbssId, bss_description->bssId); ft_session_entry->bssType = session_entry->bssType; if (ft_session_entry->bssType == eSIR_INFRASTRUCTURE_MODE) ft_session_entry->limSystemRole = eLIM_STA_ROLE; ft_session_entry->limSmeState = eLIM_SME_WT_REASSOC_STATE; mac->ft.ftPEContext.pftSessionEntry = ft_session_entry; limLog(mac, LOG1,"%s:created session (%pK) with id = %d", __func__, ft_session_entry, ft_session_entry->peSessionId); /* Update the ReAssoc BSSID of the current session */ sirCopyMacAddr(session_entry->limReAssocbssId, bss_description->bssId); limPrintMacAddr(mac, session_entry->limReAssocbssId, LOG1); /* Prepare session for roamable AP */ lim_process_preauth_mbb_result(mac, mac->ft.ftPEContext.ftPreAuthStatus, (tANI_U32 *)session_entry); return; }else { lim_handle_preauth_mbb_fail(mac, session_entry); return; } out: /* This sequence needs to be executed in case of failure*/ if (session_entry->currentOperChannel != mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum) { limChangeChannelWithCallback(mac, session_entry->currentOperChannel, lim_perform_post_preauth_mbb_channel_change, NULL, session_entry); } else { /* Link needs to be resumed as link was suspended for same channel */ peSetResumeChannel(mac, 0, 0); limResumeLink(mac, lim_process_preauth_mbb_result, (tANI_U32 *)session_entry); } } /** * lim_process_preauth_mbb_rsp_timeout() -Process preauth response timeout * @mac: MAC context * * This function is called if preauth response is not received from the AP * within timeout */ void lim_process_preauth_mbb_rsp_timeout(tpAniSirGlobal mac) { tpPESession session_entry; /* * Pre auth is failed. Need to resume link and get back on * to home channel. */ limLog(mac, LOG1, FL("Pre-Auth MBB Time Out!!!!")); if((session_entry = peFindSessionBySessionId(mac, mac->lim.limTimers.glim_pre_auth_mbb_rsp_timer.sessionId))== NULL) { limLog(mac, LOGE, FL("session does not exist for given session id")); return; } /* * To handle the race condition where we recieve preauth rsp after * timer has expired. */ if (mac->ft.ftPEContext.pFTPreAuthReq == NULL) { limLog(mac, LOGE, FL("Auth Rsp might already be posted to SME" "and cleanup done! sessionId:%d"), mac->lim.limTimers.glim_pre_auth_mbb_rsp_timer.sessionId); return; } if (eANI_BOOLEAN_TRUE == mac->ft.ftPEContext.pFTPreAuthReq->bPreAuthRspProcessed) { limLog(mac, LOGE, FL("Auth rsp already posted to SME session %pK"), session_entry); return; } else { /* * Here we are sending preauth rsp with failure state * and which is forwarded to SME. Now, if we receive an preauth * resp from AP with success it would create a FT pesession, but * will be dropped in SME leaving behind the pesession. * Mark Preauth rsp processed so that any rsp from AP is dropped in * limProcessAuthFrameNoSession. */ limLog(mac,LOG1, FL("Auth rsp not yet posted to SME session %pK)"), session_entry); mac->ft.ftPEContext.pFTPreAuthReq->bPreAuthRspProcessed = eANI_BOOLEAN_TRUE; } /* * Ok, so attempted a Pre-Auth and failed. If we are off channel. We need * to get back. */ lim_handle_pre_auth_mbb_rsp(mac, eSIR_FAILURE, session_entry); } /** * lim_process_reassoc_mbb_rsp_timeout() -Process reassoc response timeout * @mac: MAC context * * This function is called if preauth response is not received from the * AP within timeout */ void lim_process_reassoc_mbb_rsp_timeout(tpAniSirGlobal mac) { tpPESession session_entry, ft_session_entry; tANI_U8 session_id; if((ft_session_entry = peFindSessionBySessionId(mac, mac->lim.limTimers.glim_reassoc_mbb_rsp_timer.sessionId))== NULL) { limLog(mac, LOGE, FL("ft session does not exist for given session id %d"), mac->lim.limTimers.glim_reassoc_mbb_rsp_timer.sessionId); return; } limLog(mac, LOG1, FL("Reassoc timeout happened in state %d"), ft_session_entry->limMlmState); if((session_entry = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->currbssId, &session_id))== NULL) { limLog(mac, LOGE, FL("session does not exist for given BSSID" MAC_ADDRESS_STR), MAC_ADDR_ARRAY(mac->ft.ftPEContext.pFTPreAuthReq->currbssId)); return; } lim_handle_reassoc_mbb_fail(mac, ft_session_entry); } /** * lim_perform_pre_auth_reassoc() -Sends preauth request * @mac: MAC context * @status: status of message * @data: gives information of session * @session_entry: session entry * * This function process preauth request received from CSR */ static inline void lim_perform_pre_auth_reassoc(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data, tpPESession session_entry) { tSirMacAuthFrameBody authFrame; if (status != eHAL_STATUS_SUCCESS) { limLog(mac, LOGE, FL("Change channel not successful for pre-auth")); goto preauth_fail; } limLog(mac, LOGE, FL("session id %d"), session_entry->peSessionId); mac->ft.ftPEContext.psavedsessionEntry = session_entry; authFrame.authAlgoNumber = eSIR_OPEN_SYSTEM; authFrame.authTransactionSeqNumber = SIR_MAC_AUTH_FRAME_1; authFrame.authStatusCode = 0; /* Start timer here to come back to operating channel. */ mac->lim.limTimers.glim_pre_auth_mbb_rsp_timer.sessionId = session_entry->peSessionId; limSendAuthMgmtFrame(mac, &authFrame, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, LIM_NO_WEP_IN_FC, session_entry, eSIR_FALSE); MTRACE(macTrace(mac, TRACE_CODE_TIMER_ACTIVATE, session_entry->peSessionId, eLIM_PREAUTH_MBB_RSP_TIMER)); if(TX_SUCCESS != tx_timer_activate(&mac->lim.limTimers.glim_pre_auth_mbb_rsp_timer)) { limLog(mac, LOGE, FL("Pre Auth MBB Rsp Timer Start Failed")); mac->ft.ftPEContext.psavedsessionEntry = NULL; goto preauth_fail; } return; preauth_fail: lim_handle_pre_auth_mbb_rsp(mac, eSIR_FAILURE, session_entry); return; } /** * pre_auth_mbb_suspend_link_handler() -Handler for suspend link * @mac: MAC context * @status: status of message * @data: gives information of session * * This function process preauth request received from CSR */ static inline void pre_auth_mbb_suspend_link_handler(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data) { tpPESession session_entry; if (status != eHAL_STATUS_SUCCESS) { limLog(mac, LOGE, FL("Link suspend failed")); lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, (tpPESession)data, SIR_MBB_CONNECTED); return; } session_entry = (tpPESession)data; if (session_entry->currentOperChannel != mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum) { limChangeChannelWithCallback(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum, lim_perform_pre_auth_reassoc, NULL, session_entry); return; } else { lim_perform_pre_auth_reassoc(mac, eHAL_STATUS_SUCCESS, NULL, session_entry); return; } } /** * lim_process_pre_auth_reassoc_req() -Process preauth request * @hal: HAL context * @msg: message * * This function process preauth request received from CSR */ void lim_process_pre_auth_reassoc_req(tpAniSirGlobal mac, tpSirMsgQ msg) { tpPESession session_entry; tANI_U8 session_id; limFTInit(mac); /* Can set it only after sending auth */ mac->ft.ftPEContext.ftPreAuthStatus = eSIR_FAILURE; /* We need information from the Pre-Auth Req. Lets save that */ mac->ft.ftPEContext.pFTPreAuthReq = (tpSirFTPreAuthReq)msg->bodyptr; if (!mac->ft.ftPEContext.pFTPreAuthReq) { limLog(mac, LOGE, FL("pFTPreAuthReq is NULL")); lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); return; } /* Get the current session entry */ session_entry = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->currbssId, &session_id); if (session_entry == NULL) { limLog(mac, LOGE, FL("Unable to find session for the following bssid")); limPrintMacAddr(mac, mac->ft.ftPEContext.pFTPreAuthReq->currbssId, LOGE); /* Post the pre auth response to SME */ lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); return; } limLog(mac, LOG1, FL("set link with eSIR_LINK_PRE_AUTH_REASSOC_STATE")); if (limSetLinkState(mac, eSIR_LINK_PRE_AUTH_REASSOC_STATE, session_entry->bssId, session_entry->selfMacAddr, NULL, NULL) != eSIR_SUCCESS) { limLog(mac, LOGE, FL("set link failed for eSIR_LINK_PRE_AUTH_REASSOC_STATE")); lim_post_pre_auth_reassoc_rsp(mac, eSIR_FAILURE, NULL, SIR_MBB_CONNECTED); return; } /* * Suspend link for same channel or different channel so that STA * can be in power save for connected AP. */ limLog(mac, LOG1, FL("pre-auth on channel %d (session %pK) currentOperChannel %d"), mac->ft.ftPEContext.pFTPreAuthReq->preAuthchannelNum, session_entry, session_entry->currentOperChannel); limSuspendLink(mac, eSIR_CHECK_ROAMING_SCAN, pre_auth_mbb_suspend_link_handler, (tANI_U32 *)session_entry); } /** * lim_process_sta_mlm_del_sta_rsp_mbb() -Process del sta response * @mac: MAC context * @lim_msg: lim message * @session_entry: session entry * * This function process del sta response */ void lim_process_sta_mlm_del_sta_rsp_mbb(tpAniSirGlobal mac, tpSirMsgQ lim_msg, tpPESession session_entry) { tpDeleteStaParams del_sta_params = (tpDeleteStaParams)lim_msg->bodyptr; tpDphHashNode sta_ds = NULL; tANI_U8 session_id; tpPESession ft_session_entry; if(NULL == del_sta_params) { limLog(mac, LOGE, FL("Encountered NULL Pointer")); goto end; } limLog(mac, LOG1, FL("Del STA RSP received. Status:%d AssocID:%d"), del_sta_params->status, del_sta_params->assocId); if (eHAL_STATUS_SUCCESS != del_sta_params->status) { limLog(mac, LOGE, FL("Del STA failed! Status:%d, still proceeding" "with Del BSS"), del_sta_params->status); } sta_ds = dphGetHashEntry(mac, DPH_STA_HASH_INDEX_PEER, &session_entry->dph.dphHashTable); if (sta_ds == NULL) { limLog( mac, LOGE, FL("DPH Entry for STA %X missing"), del_sta_params->assocId); goto end; } if (eLIM_MLM_WT_DEL_STA_RSP_STATE != session_entry->limMlmState) { limLog(mac, LOGE, FL( "Received unexpected WDA_DELETE_STA_RSP in state %s" ), limMlmStateStr(session_entry->limMlmState)); goto end; } limLog( mac, LOG1, FL("STA AssocID %d MAC "), sta_ds->assocId); limPrintMacAddr(mac, sta_ds->staAddr, LOG1); /* * we must complete all cleanup related to del sta * before calling del bss. */ if (NULL != lim_msg->bodyptr) { vos_mem_free(del_sta_params); lim_msg->bodyptr = NULL; } /* Proceed to do del bss even if del sta resulted in failure */ lim_del_bss_mbb(mac, sta_ds, 0, session_entry); return; end: if(NULL != lim_msg->bodyptr) { vos_mem_free(del_sta_params); lim_msg->bodyptr = NULL; } /* Connected AP lim cleanup.*/ lim_cleanup_connected_ap(mac, sta_ds, session_entry); ft_session_entry = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, &session_id); if (ft_session_entry == NULL) { limLog(mac, LOGE, FL("Unable to find session for the following bssid")); limPrintMacAddr(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, LOGE); return; } /* * eHAL_STATUS_INVALID_PARAMETER is used * so that full cleanup is triggered. */ lim_reassoc_fail_cleanup(mac, eHAL_STATUS_INVALID_PARAMETER, (tANI_U32 *)ft_session_entry); } /** * lim_cleanup_rx_path_mbb() -cleans up tspec related info * @mac: MAC context * @sta_ds: station entry * @session_entry: session entry of connected AP * * This function cleans up tspec related info */ void lim_cleanup_rx_path_mbb(tpAniSirGlobal mac, tpDphHashNode sta_ds,tpPESession session_entry) { limLog(mac, LOG1, FL("AID %d limSmeState %d, mlmState %d"), sta_ds->assocId, session_entry->limSmeState, sta_ds->mlmStaContext.mlmState); session_entry->isCiscoVendorAP = FALSE; if (mac->lim.gLimAddtsSent) tx_timer_deactivate(&mac->lim.limTimers.gLimAddtsRspTimer); /* delete all tspecs associated with this sta. */ limAdmitControlDeleteSta(mac, sta_ds->assocId); } /** * lim_cleanup_connected_ap() -cleans up connected AP lim info * @mac: MAC context * @sta_ds: station entry * @session_entry: session entry of connected AP * * This function cleans up connected AP lim info */ void lim_cleanup_connected_ap(tpAniSirGlobal mac, tpDphHashNode sta_ds, tpPESession session_entry) { if (!sta_ds || !session_entry) return; lim_cleanup_rx_path_mbb(mac, sta_ds, session_entry); limDeleteDphHashEntry(mac, sta_ds->staAddr, sta_ds->assocId, session_entry); /** * Make STA hash entry invalid at eCPU so that DPH * does not process any more data packets and * releases those BDs */ sta_ds->valid = 0; peDeleteSession(mac, session_entry); } /** * lim_process_sta_mlm_del_bss_rsp_mbb() -Process del bss response of * connected AP * @mac: MAC context * @lim_msg: lim message * @session_entry: session entry of connected AP * * This function process del sta response */ void lim_process_sta_mlm_del_bss_rsp_mbb(tpAniSirGlobal mac, tpSirMsgQ lim_msg, tpPESession session_entry) { tpDeleteBssParams delbss_params = (tpDeleteBssParams)lim_msg->bodyptr; tpDphHashNode sta_ds = dphGetHashEntry(mac, DPH_STA_HASH_INDEX_PEER, &session_entry->dph.dphHashTable); tpPESession ft_session_entry; tANI_U8 session_id; if (NULL == delbss_params) { limLog(mac, LOGE, FL( "Invalid body pointer in message")); goto end; } ft_session_entry = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, &session_id); if (ft_session_entry == NULL) { limLog(mac, LOGE, FL("Unable to find session for the following bssid")); limPrintMacAddr(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, LOGE); goto end; } if(eHAL_STATUS_SUCCESS == delbss_params->status) { limLog(mac, LOG1, FL( "STA received the DEL_BSS_RSP for BSSID: %X."), delbss_params->bssIdx); if(sta_ds == NULL) { limLog(mac, LOGE, FL("DPH Entry for STA missing")); goto end; } if(eLIM_MLM_WT_DEL_BSS_RSP_STATE != session_entry->limMlmState) { limLog(mac, LOGE, FL("Received unexpected WDA_DEL_BSS_RSP in state %d"), session_entry->limMlmState); goto end; } limLog(mac, LOG1, FL("STA AssocID %d MAC "), sta_ds->assocId ); limPrintMacAddr(mac, sta_ds->staAddr, LOG1); lim_cleanup_connected_ap(mac, sta_ds, session_entry); lim_add_bss_mbb(mac, sta_ds, ft_session_entry); if(NULL != lim_msg->bodyptr) { vos_mem_free(delbss_params); lim_msg->bodyptr = NULL; } return; } else { /* * If del bss response is failure, cleanup sessions of both currently * connected AP and roamable AP as add bss can not be send * without successful delbss. */ limLog(mac, LOGE, FL("DEL BSS failed! Status:%d"), delbss_params->status); if(NULL != lim_msg->bodyptr) { vos_mem_free(delbss_params); lim_msg->bodyptr = NULL; } /* Connected AP lim cleanup.*/ lim_cleanup_connected_ap(mac, sta_ds, session_entry); /* Newly created session cleanup */ lim_reassoc_fail_cleanup(mac, eHAL_STATUS_MBB_DEL_BSS_FAIL, (tANI_U32 *)ft_session_entry); return; } end: if(NULL != lim_msg->bodyptr) { vos_mem_free(delbss_params); lim_msg->bodyptr = NULL; } lim_cleanup_connected_ap(mac, sta_ds, session_entry); ft_session_entry = peFindSessionByBssid(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, &session_id); if (ft_session_entry == NULL) { limLog(mac, LOGE, FL("Unable to find session for the following bssid")); limPrintMacAddr(mac, mac->ft.ftPEContext.pFTPreAuthReq->preAuthbssId, LOGE); return; } /* * eHAL_STATUS_INVALID_PARAMETER is used * so that full cleanup is triggered. */ lim_reassoc_fail_cleanup(mac, eHAL_STATUS_INVALID_PARAMETER, (tANI_U32 *)ft_session_entry); } void lim_fill_add_sta_params_mbb(tpAniSirGlobal mac, tpPESession session_entry, tpAddStaParams add_sta_params) { tANI_U32 listen_interval = WNI_CFG_LISTEN_INTERVAL_STADEF; tANI_U32 self_sta_dot11_mode = 0; vos_mem_copy(add_sta_params->staMac, session_entry->selfMacAddr, sizeof(tSirMacAddr)); vos_mem_copy(add_sta_params->bssId, session_entry->bssId, sizeof(tSirMacAddr)); add_sta_params->staType = STA_ENTRY_SELF; add_sta_params->status = eHAL_STATUS_SUCCESS; add_sta_params->respReqd = 1; add_sta_params->sessionId = session_entry->peSessionId; add_sta_params->staIdx = HAL_STA_INVALID_IDX; add_sta_params->updateSta = FALSE; add_sta_params->shortPreambleSupported = session_entry->beaconParams.fShortPreamble; #ifdef WLAN_FEATURE_11AC limPopulatePeerRateSet(mac, &add_sta_params->supportedRates, NULL, false,session_entry, NULL); #else limPopulatePeerRateSet(mac, &add_sta_params->supportedRates, NULL, false,session_entry); #endif if(session_entry->htCapability) { add_sta_params->htCapable = session_entry->htCapability; #ifdef WLAN_FEATURE_11AC add_sta_params->vhtCapable = session_entry->vhtCapability; add_sta_params->vhtTxChannelWidthSet = session_entry->vhtTxChannelWidthSet; #endif #ifdef DISABLE_GF_FOR_INTEROP if((session_entry->pLimJoinReq != NULL) && (!session_entry->pLimJoinReq->bssDescription.aniIndicator)) { limLog(mac, LOGE, FL("Turning off Greenfield, when adding self entry")); add_sta_params->greenFieldCapable = WNI_CFG_GREENFIELD_CAPABILITY_DISABLE; } else #endif add_sta_params->greenFieldCapable = limGetHTCapability( mac, eHT_GREENFIELD, session_entry); if (session_entry->limRFBand == SIR_BAND_2_4_GHZ) add_sta_params->txChannelWidthSet = mac->roam.configParam.channelBondingMode24GHz; else add_sta_params->txChannelWidthSet = mac->roam.configParam.channelBondingMode5GHz; add_sta_params->mimoPS = limGetHTCapability(mac, eHT_MIMO_POWER_SAVE, session_entry); add_sta_params->rifsMode = limGetHTCapability(mac, eHT_RIFS_MODE, session_entry); add_sta_params->lsigTxopProtection = limGetHTCapability(mac, eHT_LSIG_TXOP_PROTECTION, session_entry); add_sta_params->delBASupport = limGetHTCapability(mac, eHT_DELAYED_BA, session_entry); add_sta_params->maxAmpduDensity = limGetHTCapability(mac, eHT_MPDU_DENSITY, session_entry); add_sta_params->maxAmpduSize = limGetHTCapability(mac, eHT_MAX_RX_AMPDU_FACTOR, session_entry); add_sta_params->maxAmsduSize = limGetHTCapability(mac, eHT_MAX_AMSDU_LENGTH, session_entry); add_sta_params->fDsssCckMode40Mhz = limGetHTCapability(mac, eHT_DSSS_CCK_MODE_40MHZ, session_entry); add_sta_params->fShortGI20Mhz = limGetHTCapability(mac, eHT_SHORT_GI_20MHZ, session_entry); add_sta_params->fShortGI40Mhz = limGetHTCapability(mac, eHT_SHORT_GI_40MHZ, session_entry); } if (wlan_cfgGetInt(mac, WNI_CFG_LISTEN_INTERVAL, &listen_interval) != eSIR_SUCCESS) limLog(mac, LOGE, FL("Couldn't get LISTEN_INTERVAL")); add_sta_params->listenInterval = (tANI_U16)listen_interval; wlan_cfgGetInt(mac, WNI_CFG_DOT11_MODE, &self_sta_dot11_mode); add_sta_params->supportedRates.opRateMode = limGetStaRateMode((tANI_U8)self_sta_dot11_mode); mac->ft.ftPEContext.pAddStaReq = add_sta_params; } void lim_process_sta_mlm_add_bss_rsp_mbb(tpAniSirGlobal mac, tpSirMsgQ limMsgQ,tpPESession session_entry) { tpAddBssParams add_bss_params = (tpAddBssParams)limMsgQ->bodyptr; tpAddStaParams add_sta_params = NULL; tpDphHashNode sta_ds = dphGetHashEntry(mac, DPH_STA_HASH_INDEX_PEER, &session_entry->dph.dphHashTable); if(add_bss_params == 0) goto end; if (!sta_ds) { limLog(mac, LOGE, FL("DPH Entry for STA missing")); goto end; } limLog(mac, LOG1, FL("Add BSS RSP received. Status:%d"), add_bss_params->status); if(eHAL_STATUS_SUCCESS == add_bss_params->status) { if(eLIM_MLM_WT_ADD_BSS_RSP_REASSOC_STATE != session_entry->limMlmState) { limLog(mac, LOGE, FL("Received unexpected ADD BSS in state %d"), session_entry->limMlmState); goto end; } session_entry->bssIdx = add_bss_params->bssIdx; sta_ds->bssId = add_bss_params->bssIdx; sta_ds->staIndex = add_bss_params->staContext.staIdx; sta_ds->ucUcastSig = add_bss_params->staContext.ucUcastSig; sta_ds->ucBcastSig = add_bss_params->staContext.ucBcastSig; rrmCacheMgmtTxPower(mac, add_bss_params->txMgmtPower, session_entry); /* Allocate memory for add sta params */ add_sta_params = vos_mem_malloc(sizeof( tAddStaParams )); if (NULL == add_sta_params) { limLog(mac, LOGE, FL("Unable to allocate memory during ADD_STA")); goto end; } vos_mem_set(add_sta_params, sizeof(tAddStaParams), 0); /* Prepare add sta params */ lim_fill_add_sta_params_mbb(mac, session_entry, add_sta_params); if(0 != limMsgQ->bodyptr) { vos_mem_free(add_bss_params); add_bss_params = NULL; limMsgQ->bodyptr = NULL; } lim_add_sta_mbb(mac, session_entry->limAID, session_entry); } else { /* * If add bss response is failure, cleanup session of roamable AP * as cleanup of connected bss happened during del bss */ limLog(mac, LOGE, FL("ADD BSS failed! Status:%d"), add_bss_params->status); /* Newly created session cleanup */ lim_reassoc_fail_cleanup(mac, eHAL_STATUS_MBB_ADD_BSS_FAIL, (tANI_U32 *)session_entry); } end: if(0 != limMsgQ->bodyptr) { vos_mem_free(add_bss_params); add_bss_params = NULL; limMsgQ->bodyptr = NULL; } } /* * lim_perform_post_add_sta_rsp() -invokes resume callback to handle add sta response * @mac: MAC context * @status: status * @data: pointer to data * * This function invokes resume callback */ void lim_perform_post_add_sta_rsp(tpAniSirGlobal mac, eHalStatus status, tANI_U32 *data) { tpDphHashNode sta_ds; /* session entry for newly roamed ap */ tpPESession session_entry; session_entry = (tpPESession)data; limLog(mac, LOG1, FL("forwarding cached packets")); WLANTL_PreAssocForward(true); sta_ds = dphGetHashEntry(mac, DPH_STA_HASH_INDEX_PEER, &session_entry->dph.dphHashTable); if(NULL != sta_ds) sta_ds->mlmStaContext.mlmState = eLIM_MLM_LINK_ESTABLISHED_STATE; else { limLog(mac, LOGE, FL("Unable to get the DPH Hash Entry for AID - %d"), DPH_STA_HASH_INDEX_PEER); return; } session_entry->limMlmState = eLIM_MLM_LINK_ESTABLISHED_STATE; MTRACE(macTrace(mac, TRACE_CODE_MLM_STATE, session_entry->peSessionId, eLIM_MLM_LINK_ESTABLISHED_STATE)); #ifdef FEATURE_WLAN_TDLS /* initialize TDLS peer related data */ limInitTdlsData(mac, session_entry); #endif if (limSetLinkState(mac, eSIR_LINK_POSTASSOC_STATE, session_entry->bssId, session_entry->selfMacAddr, NULL, NULL) != eSIR_SUCCESS) { limLog(mac, LOGE, FL("Set link state to POSTASSOC failed")); return; } session_entry->limSmeState = eLIM_SME_LINK_EST_STATE; lim_post_pre_auth_reassoc_rsp(mac, eSIR_SUCCESS, session_entry, SIR_MBB_CONNECTED); /* Freeup the cached preauth request */ if (mac->ft.ftPEContext.pFTPreAuthReq) { limLog(mac, LOG1, FL("Freeing pFTPreAuthReq= %pK"), mac->ft.ftPEContext.pFTPreAuthReq); if (mac->ft.ftPEContext.pFTPreAuthReq->pbssDescription) { vos_mem_free(mac->ft.ftPEContext.pFTPreAuthReq->pbssDescription); mac->ft.ftPEContext.pFTPreAuthReq->pbssDescription = NULL; } vos_mem_free(mac->ft.ftPEContext.pFTPreAuthReq); mac->ft.ftPEContext.pFTPreAuthReq = NULL; } } void lim_process_sta_mlm_add_sta_rsp_mbb(tpAniSirGlobal mac, tpSirMsgQ limMsgQ,tpPESession session_entry) { tpAddStaParams add_sta_params = (tpAddStaParams)limMsgQ->bodyptr; if(NULL == add_sta_params) { limLog(mac, LOGE, FL("Encountered NULL Pointer")); return; } limLog(mac, LOG1, FL("Add STA RSP received. Status:%d"), add_sta_params->status); if (eHAL_STATUS_SUCCESS == add_sta_params->status) { if ( eLIM_MLM_WT_ADD_STA_RSP_STATE != session_entry->limMlmState) { limLog(mac, LOGE, FL("Received unexpected ADD_STA_RSP in state %d"), session_entry->limMlmState); goto end; } /* * Storing the self StaIndex(Generated by HAL) in session context, * instead of storing it in DPH Hash entry for Self STA. * DPH entry for the self STA stores the sta index for the BSS entry * to which the STA is associated. */ session_entry->staId = add_sta_params->staIdx; limLog(mac, LOG1, FL("resuming to oper ch %d"), session_entry->currentOperChannel); peSetResumeChannel(mac, session_entry->currentOperChannel, 0); limResumeLink(mac, lim_perform_post_add_sta_rsp, (tANI_U32 *)session_entry); } else { limLog(mac, LOGE, FL( "ADD_STA failed!")); /* Newly created session cleanup */ lim_reassoc_fail_cleanup(mac, eHAL_STATUS_MBB_ADD_BSS_FAIL, (tANI_U32 *)session_entry); } end: if( 0 != limMsgQ->bodyptr ) { vos_mem_free(add_sta_params); limMsgQ->bodyptr = NULL; } } eAniBoolean lim_is_mbb_reassoc_in_progress(tpAniSirGlobal mac, tpPESession session_entry) { if (session_entry == NULL) return eANI_BOOLEAN_FALSE; if ((eLIM_STA_ROLE == session_entry->limSystemRole) && mac->ft.ftSmeContext.is_preauth_lfr_mbb) { limLog(mac, LOG1, FL("MBB Reassoc in progress")); return eANI_BOOLEAN_TRUE; } return eANI_BOOLEAN_FALSE; }