float block_queue::get_speed(const boost::uuids::uuid &connection_id) const
{
boost::unique_lock<boost::recursive_mutex> lock(mutex);
std::unordered_map<boost::uuids::uuid, float> speeds;
for (const auto &span: blocks)
{
if (span.blocks.empty())
continue;
// note that the average below does not average over the whole set, but over the
// previous pseudo average and the latest rate: this gives much more importance
// to the latest measurements, which is fine here
std::unordered_map<boost::uuids::uuid, float>::iterator i = speeds.find(span.connection_id);
if (i == speeds.end())
speeds.insert(std::make_pair(span.connection_id, span.rate));
else
i->second = (i->second + span.rate) / 2;
}
float conn_rate = -1, best_rate = 0;
for (auto i: speeds)
{
if (i.first == connection_id)
conn_rate = i.second;
if (i.second > best_rate)
best_rate = i.second;
}
if (conn_rate <= 0)
return 1.0f; // not found, assume good speed
if (best_rate == 0)
return 1.0f; // everything dead ? Can't happen, but let's trap anyway
const float speed = conn_rate / best_rate;
MTRACE(" Relative speed for " << connection_id << ": " << speed << " (" << conn_rate << "/" << best_rate);
return speed;
}
tANI_U32
limDeactivateMinChannelTimerDuringScan(tpAniSirGlobal pMac)
{
if ((pMac->lim.gLimMlmState == eLIM_MLM_WT_PROBE_RESP_STATE) && (pMac->lim.gLimHalScanState == eLIM_HAL_SCANNING_STATE))
{
/**
* Beacon/Probe Response is received during active scanning.
* Deactivate MIN channel timer if running.
*/
limDeactivateAndChangeTimer(pMac,eLIM_MIN_CHANNEL_TIMER);
MTRACE(macTrace(pMac, TRACE_CODE_TIMER_ACTIVATE, NO_SESSION, eLIM_MAX_CHANNEL_TIMER));
if (tx_timer_activate(&pMac->lim.limTimers.gLimMaxChannelTimer)
== TX_TIMER_ERROR)
{
/// Could not activate max channel timer.
// Log error
limLog(pMac,LOGP, FL("could not activate max channel timer"));
limCompleteMlmScan(pMac, eSIR_SME_RESOURCES_UNAVAILABLE);
return TX_TIMER_ERROR;
}
}
return eSIR_SUCCESS;
} /*** end limDeactivateMinChannelTimerDuringScan() ***/
void lim_update_re_assoc_globals(tpAniSirGlobal pMac, tpSirAssocRsp pAssocRsp,
tpPESession psessionEntry)
{
/* Update the current Bss Information */
cdf_mem_copy(psessionEntry->bssId,
psessionEntry->limReAssocbssId, sizeof(tSirMacAddr));
psessionEntry->currentOperChannel = psessionEntry->limReassocChannelId;
psessionEntry->htSecondaryChannelOffset =
psessionEntry->reAssocHtSupportedChannelWidthSet;
psessionEntry->htRecommendedTxWidthSet =
psessionEntry->reAssocHtRecommendedTxWidthSet;
psessionEntry->htSecondaryChannelOffset =
psessionEntry->reAssocHtSecondaryChannelOffset;
psessionEntry->limCurrentBssCaps = psessionEntry->limReassocBssCaps;
psessionEntry->limCurrentBssQosCaps =
psessionEntry->limReassocBssQosCaps;
psessionEntry->limCurrentBssPropCap =
psessionEntry->limReassocBssPropCap;
cdf_mem_copy((uint8_t *) &psessionEntry->ssId,
(uint8_t *) &psessionEntry->limReassocSSID,
psessionEntry->limReassocSSID.length + 1);
/* Store assigned AID for TIM processing */
psessionEntry->limAID = pAssocRsp->aid & 0x3FFF;
/** Set the State Back to ReAssoc Rsp*/
psessionEntry->limMlmState = eLIM_MLM_WT_REASSOC_RSP_STATE;
MTRACE(mac_trace
(pMac, TRACE_CODE_MLM_STATE, psessionEntry->peSessionId,
psessionEntry->limMlmState));
}
void connection_basic::sleep_before_packet(size_t packet_size, int phase, int q_len) {
double delay=0; // will be calculated
do
{ // rate limiting
if (m_was_shutdown) {
_dbg2("m_was_shutdown - so abort sleep");
return;
}
{
CRITICAL_REGION_LOCAL( network_throttle_manager::m_lock_get_global_throttle_out );
delay = network_throttle_manager::get_global_throttle_out().get_sleep_time_after_tick( packet_size );
}
delay *= 0.50;
if (delay > 0) {
long int ms = (long int)(delay * 1000);
MTRACE("Sleeping in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<packet_size); // debug sleep
boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) );
}
} while(delay > 0);
// XXX LATER XXX
{
CRITICAL_REGION_LOCAL( network_throttle_manager::m_lock_get_global_throttle_out );
network_throttle_manager::get_global_throttle_out().handle_trafic_exact( packet_size ); // increase counter - global
}
}
/**
* lim_send_cf_params()
*
***FUNCTION:
* This function is called to send CFP Parameters to WMA, when they are changed.
*
***LOGIC:
*
***ASSUMPTIONS:
* NA
*
***NOTE:
* NA
*
* @param pMac pointer to Global Mac structure.
* @param bssIdx Bss Index of the BSS to which STA is associated.
* @param cfpCount CFP Count, if that is changed.
* @param cfpPeriod CFP Period if that is changed.
*
* @return success if message send is ok, else false.
*/
tSirRetStatus lim_send_cf_params(tpAniSirGlobal pMac, uint8_t bssIdx,
uint8_t cfpCount, uint8_t cfpPeriod)
{
tpUpdateCFParams pCFParams = NULL;
tSirRetStatus retCode = eSIR_SUCCESS;
tSirMsgQ msgQ;
pCFParams = cdf_mem_malloc(sizeof(tUpdateCFParams));
if (NULL == pCFParams) {
lim_log(pMac, LOGP,
FL("Unable to allocate memory during Update CF Params"));
retCode = eSIR_MEM_ALLOC_FAILED;
goto returnFailure;
}
cdf_mem_set((uint8_t *) pCFParams, sizeof(tUpdateCFParams), 0);
pCFParams->cfpCount = cfpCount;
pCFParams->cfpPeriod = cfpPeriod;
pCFParams->bssIdx = bssIdx;
msgQ.type = WMA_UPDATE_CF_IND;
msgQ.reserved = 0;
msgQ.bodyptr = pCFParams;
msgQ.bodyval = 0;
lim_log(pMac, LOG3, FL("Sending WMA_UPDATE_CF_IND..."));
MTRACE(mac_trace_msg_tx(pMac, NO_SESSION, msgQ.type));
retCode = wma_post_ctrl_msg(pMac, &msgQ);
if (eSIR_SUCCESS != retCode) {
cdf_mem_free(pCFParams);
lim_log(pMac, LOGP,
FL("Posting WMA_UPDATE_CF_IND failed, reason=%X"),
retCode);
}
returnFailure:
return retCode;
}
void
limReleasePreAuthNode(tpAniSirGlobal pMac, tpLimPreAuthNode pAuthNode)
{
pAuthNode->fFree = 1;
MTRACE(macTrace(pMac, TRACE_CODE_TIMER_DEACTIVATE, NO_SESSION, eLIM_PRE_AUTH_CLEANUP_TIMER));
tx_timer_deactivate(&pAuthNode->timer);
pMac->lim.gLimNumPreAuthContexts--;
} /*** end limReleasePreAuthNode() ***/
void
limRestoreFromAuthState(tpAniSirGlobal pMac, tSirResultCodes resultCode, tANI_U16 protStatusCode,tpPESession sessionEntry)
{
tSirMacAddr currentBssId;
tLimMlmAuthCnf mlmAuthCnf;
vos_mem_copy( (tANI_U8 *) &mlmAuthCnf.peerMacAddr,
(tANI_U8 *) &pMac->lim.gpLimMlmAuthReq->peerMacAddr,
sizeof(tSirMacAddr));
mlmAuthCnf.authType = pMac->lim.gpLimMlmAuthReq->authType;
mlmAuthCnf.resultCode = resultCode;
mlmAuthCnf.protStatusCode = protStatusCode;
/* Update PE session ID*/
mlmAuthCnf.sessionId = sessionEntry->peSessionId;
/// Free up buffer allocated
/// for pMac->lim.gLimMlmAuthReq
vos_mem_free(pMac->lim.gpLimMlmAuthReq);
pMac->lim.gpLimMlmAuthReq = NULL;
sessionEntry->limMlmState = sessionEntry->limPrevMlmState;
MTRACE(macTrace(pMac, TRACE_CODE_MLM_STATE, sessionEntry->peSessionId, sessionEntry->limMlmState));
// 'Change' timer for future activations
limDeactivateAndChangeTimer(pMac, eLIM_AUTH_FAIL_TIMER);
#if 0
if (wlan_cfgGetStr(pMac, WNI_CFG_BSSID, currentBssId, &cfg) != eSIR_SUCCESS)
{
/// Could not get BSSID from CFG. Log error.
limLog(pMac, LOGP, FL("could not retrieve BSSID"));
}
#endif //TO SUPPORT BT-AMP
sirCopyMacAddr(currentBssId,sessionEntry->bssId);
if (sessionEntry->limSmeState == eLIM_SME_WT_PRE_AUTH_STATE)
{
pMac->lim.gLimPreAuthChannelNumber = 0;
}
limPostSmeMessage(pMac,
LIM_MLM_AUTH_CNF,
(tANI_U32 *) &mlmAuthCnf);
} /*** end limRestoreFromAuthState() ***/
static void __limInitStates(tpAniSirGlobal pMac)
{
pMac->lim.gLimHBfailureCntInLinkEstState = 0;
pMac->lim.gLimProbeFailureAfterHBfailedCnt = 0;
pMac->lim.gLimHBfailureCntInOtherStates = 0;
pMac->lim.gLimRspReqd = 0;
pMac->lim.gLimPrevSmeState = eLIM_SME_OFFLINE_STATE;
MTRACE(macTrace(pMac, TRACE_CODE_MLM_STATE, NO_SESSION, eLIM_MLM_IDLE_STATE));
pMac->lim.gLimMlmState = eLIM_MLM_IDLE_STATE;
pMac->lim.gLimPrevMlmState = eLIM_MLM_OFFLINE_STATE;
#ifdef GEN4_SCAN
pMac->lim.gLimHalScanState = eLIM_HAL_IDLE_SCAN_STATE;
#endif
pMac->lim.gLimSmeState = eLIM_SME_OFFLINE_STATE;
vos_mem_set(&pMac->lim.gLimOverlap11gParams, sizeof(tLimProtStaParams), 0);
vos_mem_set(&pMac->lim.gLimOverlap11aParams, sizeof(tLimProtStaParams), 0);
vos_mem_set(&pMac->lim.gLimOverlapHt20Params, sizeof(tLimProtStaParams), 0);
vos_mem_set(&pMac->lim.gLimOverlapNonGfParams, sizeof(tLimProtStaParams), 0);
vos_mem_set(&pMac->lim.gLimNoShortParams, sizeof(tLimNoShortParams), 0);
vos_mem_set(&pMac->lim.gLimNoShortSlotParams, sizeof(tLimNoShortSlotParams), 0);
pMac->lim.gLimPhyMode = 0;
pMac->lim.scanStartTime = 0;
vos_mem_set(pMac->lim.gLimMyMacAddr, sizeof(pMac->lim.gLimMyMacAddr), 0);
pMac->lim.ackPolicy = 0;
#if 0
pMac->lim.gLimQosEnabled = 0;
pMac->lim.gLimWmeEnabled = 0;
pMac->lim.gLimWsmEnabled = 0;
pMac->lim.gLimHcfEnabled = 0;
pMac->lim.gLim11dEnabled = 0;
#endif
pMac->lim.gLimProbeRespDisableFlag = 0;
}
void
initXEmbedServerData() {
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jclass clazz;
MTRACE("initXEmbedServerData\n");
XA_XEmbedInfo = XInternAtom(awt_display, "_XEMBED_INFO", False);
XA_XEmbed = XInternAtom(awt_display, "_XEMBED", False);
clazz = (*env)->FindClass(env, "sun/awt/motif/MEmbedCanvasPeer");
DASSERT(clazz != NULL);
requestXEmbedFocusMID = (*env)->GetMethodID(env, clazz, "requestXEmbedFocus", "()V");
DASSERT(requestXEmbedFocusMID != NULL);
focusNextMID = (*env)->GetMethodID(env, clazz, "focusNext", "()V");
DASSERT(focusNextMID != NULL);
focusPrevMID = (*env)->GetMethodID(env, clazz, "focusPrev", "()V");
DASSERT(focusPrevMID != NULL);
registerAcceleratorMID = (*env)->GetMethodID(env, clazz, "registerAccelerator", "(JJJ)V");
DASSERT(registerAcceleratorMID != NULL);
unregisterAcceleratorMID = (*env)->GetMethodID(env, clazz, "unregisterAccelerator", "(J)V");
DASSERT(unregisterAcceleratorMID != NULL);
grabKeyMID = (*env)->GetMethodID(env, clazz, "grabKey", "(JJ)V");
DASSERT(grabKeyMID != NULL);
ungrabKeyMID = (*env)->GetMethodID(env, clazz, "ungrabKey", "(JJ)V");
DASSERT(ungrabKeyMID != NULL);
childResizedMID = (*env)->GetMethodID(env, clazz, "childResized", "()V");
DASSERT(childResizedMID != NULL);
setXEmbedDropTargetMID =
(*env)->GetMethodID(env, clazz, "setXEmbedDropTarget", "()V");
DASSERT(setXEmbedDropTargetMID != NULL);
removeXEmbedDropTargetMID =
(*env)->GetMethodID(env, clazz, "removeXEmbedDropTarget", "()V");
DASSERT(removeXEmbedDropTargetMID != NULL);
applicationActiveFID = (*env)->GetFieldID(env, clazz, "applicationActive", "Z");
DASSERT(applicationActiveFID != NULL);
(*env)->DeleteLocalRef(env, clazz);
clazz = (*env)->FindClass(env, "sun/awt/motif/GrabbedKey");
DASSERT(clazz != NULL);
keysymFID = (*env)->GetFieldID(env, clazz, "keysym", "J");
DASSERT(keysymFID != NULL);
modifiersFID = (*env)->GetFieldID(env, clazz, "modifiers", "J");
DASSERT(modifiersFID != NULL);
(*env)->DeleteLocalRef(env, clazz);
}
void network_throttle::_handle_trafic_exact(size_t packet_size, size_t orginal_size)
{
tick();
calculate_times_struct cts ; calculate_times(packet_size, cts , false, -1);
calculate_times_struct cts2; calculate_times(packet_size, cts2, false, 5);
m_history[0].m_size += packet_size;
std::ostringstream oss; oss << "["; for (auto sample: m_history) oss << sample.m_size << " "; oss << "]" << std::ends;
std::string history_str = oss.str();
MTRACE("Throttle " << m_name << ": packet of ~"<<packet_size<<"b " << " (from "<<orginal_size<<" b)"
<< " Speed AVG=" << std::setw(4) << ((long int)(cts .average/1024)) <<"[w="<<cts .window<<"]"
<< " " << std::setw(4) << ((long int)(cts2.average/1024)) <<"[w="<<cts2.window<<"]"
<<" / " << " Limit="<< ((long int)(m_target_speed/1024)) <<" KiB/sec "
<< " " << history_str
);
}
/**
* limSendCFParams()
*
*FUNCTION:
* This function is called to send CFP Parameters to WDA, when they are changed.
*
*LOGIC:
*
*ASSUMPTIONS:
* NA
*
*NOTE:
* NA
*
* @param pMac pointer to Global Mac structure.
* @param bssIdx Bss Index of the BSS to which STA is associated.
* @param cfpCount CFP Count, if that is changed.
* @param cfpPeriod CFP Period if that is changed.
*
* @return success if message send is ok, else false.
*/
tSirRetStatus limSendCFParams(tpAniSirGlobal pMac, tANI_U8 bssIdx, tANI_U8 cfpCount, tANI_U8 cfpPeriod)
{
tpUpdateCFParams pCFParams = NULL;
tSirRetStatus retCode = eSIR_SUCCESS;
tSirMsgQ msgQ;
if( eHAL_STATUS_SUCCESS != palAllocateMemory( pMac->hHdd,
(void **) &pCFParams,
sizeof( tUpdateCFParams )))
{
limLog( pMac, LOGP,
FL( "Unable to PAL allocate memory during Update CF Params\n" ));
retCode = eSIR_MEM_ALLOC_FAILED;
goto returnFailure;
}
palZeroMemory( pMac->hHdd, (tANI_U8 *) pCFParams, sizeof(tUpdateCFParams));
pCFParams->cfpCount = cfpCount;
pCFParams->cfpPeriod = cfpPeriod;
pCFParams->bssIdx = bssIdx;
msgQ.type = WDA_UPDATE_CF_IND;
msgQ.reserved = 0;
msgQ.bodyptr = pCFParams;
msgQ.bodyval = 0;
limLog( pMac, LOG3,
FL( "Sending WDA_UPDATE_CF_IND..." ));
MTRACE(macTraceMsgTx(pMac, NO_SESSION, msgQ.type));
if( eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( pMac, &msgQ )))
{
palFreeMemory(pMac->hHdd, pCFParams);
limLog( pMac, LOGP,
FL("Posting WDA_UPDATE_CF_IND to WDA failed, reason=%X\n"),
retCode );
}
returnFailure:
return retCode;
}
/**
* limSendCFParams()
*
*FUNCTION:
* This function is called to send CFP Parameters to WDA, when they are changed.
*
*LOGIC:
*
*ASSUMPTIONS:
* NA
*
*NOTE:
* NA
*
* @param pMac pointer to Global Mac structure.
* @param bssIdx Bss Index of the BSS to which STA is associated.
* @param cfpCount CFP Count, if that is changed.
* @param cfpPeriod CFP Period if that is changed.
*
* @return success if message send is ok, else false.
*/
tSirRetStatus limSendCFParams(tpAniSirGlobal pMac, tANI_U8 bssIdx, tANI_U8 cfpCount, tANI_U8 cfpPeriod)
{
tpUpdateCFParams pCFParams = NULL;
tSirRetStatus retCode = eSIR_SUCCESS;
tSirMsgQ msgQ;
pCFParams = vos_mem_malloc(sizeof( tUpdateCFParams ));
if ( NULL == pCFParams )
{
limLog( pMac, LOGP,
FL( "Unable to allocate memory during Update CF Params" ));
retCode = eSIR_MEM_ALLOC_FAILED;
goto returnFailure;
}
vos_mem_set( (tANI_U8 *) pCFParams, sizeof(tUpdateCFParams), 0);
pCFParams->cfpCount = cfpCount;
pCFParams->cfpPeriod = cfpPeriod;
pCFParams->bssIdx = bssIdx;
msgQ.type = WDA_UPDATE_CF_IND;
msgQ.reserved = 0;
msgQ.bodyptr = pCFParams;
msgQ.bodyval = 0;
limLog( pMac, LOG3,
FL( "Sending WDA_UPDATE_CF_IND..." ));
MTRACE(macTraceMsgTx(pMac, NO_SESSION, msgQ.type));
if( eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( pMac, &msgQ )))
{
vos_mem_free(pCFParams);
limLog( pMac, LOGP,
FL("Posting WDA_UPDATE_CF_IND to WDA failed, reason=%X"),
retCode );
}
returnFailure:
return retCode;
}
void MNetLink::SetLinkState(MNetLink::LINKSTATE nState)
{
if (m_nLinkState == nState)
return;
m_nLinkState = nState;
#ifdef LINKSTATE_LOG
switch(m_nLinkState) {
case LINKSTATE_CLOSED:
Setconnected(false);
MTRACE("<LINK_STATE> LINKSTATE_CLOSED \n");
if (m_pSafeUDP && m_pSafeUDP->m_fnNetLinkStateCallback)
m_pSafeUDP->m_fnNetLinkStateCallback(this, LINKSTATE_CLOSED);
break;
case LINKSTATE_ESTABLISHED:
Setconnected(true);
MTRACE("<LINK_STATE> LINKSTATE_ESTABLISHED \n");
if (m_pSafeUDP && m_pSafeUDP->m_fnNetLinkStateCallback)
m_pSafeUDP->m_fnNetLinkStateCallback(this, LINKSTATE_ESTABLISHED);
break;
case LINKSTATE_SYN_SENT:
MTRACE("<LINK_STATE> LINKSTATE_SYN_SENT \n");
break;
case LINKSTATE_SYN_RCVD:
MTRACE("<LINK_STATE> LINKSTATE_SYN_RCVD \n");
break;
case LINKSTATE_FIN_SENT:
MTRACE("<LINK_STATE> LINKSTATE_FIN_SENT \n");
break;
case LINKSTATE_FIN_RCVD:
MTRACE("<LINK_STATE> LINKSTATE_FIN_RCVD \n");
break;
};
#endif
}
void connection_basic::do_send_handler_write_from_queue( const boost::system::error_code& e, size_t cb, int q_len ) {
// No sleeping here; sleeping is done once and for all in connection<t_protocol_handler>::handle_write
MTRACE("handler_write (after write, from queue="<<q_len<<") - before ASIO write, for packet="<<cb<<" B (after sleep)");
}
void connection_basic::do_send_handler_write(const void* ptr , size_t cb ) {
// No sleeping here; sleeping is done once and for all in connection<t_protocol_handler>::handle_write
MTRACE("handler_write (direct) - before ASIO write, for packet="<<cb<<" B (after sleep)");
}
/**
* sysBbtProcessMessageCore
*
* FUNCTION:
* Process BBT messages
*
* LOGIC:
*
* ASSUMPTIONS:
*
* NOTE:
*
* @param tpAniSirGlobal A pointer to MAC params instance
* @param pMsg message pointer
* @param tANI_U32 type
* @param tANI_U32 sub type
* @return None
*/
tSirRetStatus
sysBbtProcessMessageCore(tpAniSirGlobal pMac, tpSirMsgQ pMsg, tANI_U32 type,
tANI_U32 subType)
{
tANI_U32 framecount;
tSirRetStatus ret;
void* pBd;
tMgmtFrmDropReason dropReason;
vos_pkt_t *pVosPkt = (vos_pkt_t *)pMsg->bodyptr;
VOS_STATUS vosStatus =
WDA_DS_PeekRxPacketInfo( pVosPkt, (v_PVOID_t *)&pBd, VOS_FALSE );
pMac->sys.gSysBbtReceived++;
if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
{
goto fail;
}
sysLog(pMac, LOG3, FL("Rx Mgmt Frame Subtype: %d\n"), subType);
sirDumpBuf(pMac, SIR_SYS_MODULE_ID, LOG3, (tANI_U8 *)WDA_GET_RX_MAC_HEADER(pBd), WDA_GET_RX_MPDU_LEN(pBd));
sirDumpBuf(pMac, SIR_SYS_MODULE_ID, LOG3, WDA_GET_RX_MPDU_DATA(pBd), WDA_GET_RX_PAYLOAD_LEN(pBd));
pMac->sys.gSysFrameCount[type][subType]++;
framecount = pMac->sys.gSysFrameCount[type][subType];
if(type == SIR_MAC_MGMT_FRAME)
{
tpSirMacMgmtHdr mac_hdr;
/*
* Drop beacon frames in deferred state to avoid VOSS run out of
* message wrappers.
*/
if ((subType == SIR_MAC_MGMT_BEACON) &&
(!limIsSystemInScanState(pMac)) &&
(true != GET_LIM_PROCESS_DEFD_MESGS(pMac)) &&
!pMac->lim.gLimSystemInScanLearnMode) {
sysLog(pMac, LOG1,
FL("dropping received beacon in deffered state"));
goto fail;
}
dropReason = limIsPktCandidateForDrop(pMac, pBd, subType);
if (dropReason != eMGMT_DROP_NO_DROP) {
sysLog(pMac, LOG1,
FL("Mgmt Frame %d being dropped, reason: %d\n"),
subType, dropReason);
MTRACE(macTrace(pMac, TRACE_CODE_RX_MGMT_DROP, NO_SESSION, dropReason));
goto fail;
}
mac_hdr = WDA_GET_RX_MAC_HEADER(pBd);
if (subType == SIR_MAC_MGMT_ASSOC_REQ) {
sysLog(pMac, LOG1,
FL("ASSOC REQ frame allowed: da: " MAC_ADDRESS_STR ", sa: " MAC_ADDRESS_STR ", bssid: " MAC_ADDRESS_STR ", Assoc Req count so far: %d\n"),
MAC_ADDR_ARRAY(mac_hdr->da),
MAC_ADDR_ARRAY(mac_hdr->sa),
MAC_ADDR_ARRAY(mac_hdr->bssId),
pMac->sys.gSysFrameCount[type][subType]);
}
if (subType == SIR_MAC_MGMT_DEAUTH)
{
sysLog(pMac, LOG1,
FL("DEAUTH frame allowed: da: " MAC_ADDRESS_STR ", sa: " MAC_ADDRESS_STR ", bssid: " MAC_ADDRESS_STR ", DEAUTH count so far: %d\n"),
MAC_ADDR_ARRAY(mac_hdr->da),
MAC_ADDR_ARRAY(mac_hdr->sa),
MAC_ADDR_ARRAY(mac_hdr->bssId),
pMac->sys.gSysFrameCount[type][subType]);
}
if (subType == SIR_MAC_MGMT_DISASSOC)
{
sysLog(pMac, LOG1,
FL("DISASSOC frame allowed: da: " MAC_ADDRESS_STR ", sa: " MAC_ADDRESS_STR ", bssid: " MAC_ADDRESS_STR ", DISASSOC count so far: %d\n"),
MAC_ADDR_ARRAY(mac_hdr->da),
MAC_ADDR_ARRAY(mac_hdr->sa),
MAC_ADDR_ARRAY(mac_hdr->bssId),
pMac->sys.gSysFrameCount[type][subType]);
}
//Post the message to PE Queue
ret = (tSirRetStatus) limPostMsgApi(pMac, pMsg);
if (ret != eSIR_SUCCESS)
{
/* Print only one debug failure out of 512 failure messages */
if(pMac->sys.gSysBbtReceived & 0x0200)
sysLog(pMac, LOGE,
FL("posting to LIM2 failed, ret %d"), ret);
goto fail;
}
pMac->sys.gSysBbtPostedToLim++;
}
else if (type == SIR_MAC_DATA_FRAME)
{
#ifdef FEATURE_WLAN_ESE
sysLog(pMac, LOGW, FL("IAPP Frame...\n"));
//Post the message to PE Queue
ret = (tSirRetStatus) limPostMsgApi(pMac, pMsg);
if (ret != eSIR_SUCCESS)
{
sysLog(pMac, LOGE, FL("posting to LIM2 failed, ret %d\n"), ret);
goto fail;
}
pMac->sys.gSysBbtPostedToLim++;
#endif
}
else
{
sysLog(pMac, LOG3, "BBT received Invalid type %d subType %d "
"LIM state %X. BD dump is:\n",
type, subType, limGetSmeState(pMac));
sirDumpBuf(pMac, SIR_SYS_MODULE_ID, LOG3,
(tANI_U8 *) pBd, WLANHAL_RX_BD_HEADER_SIZE);
goto fail;
}
return eSIR_SUCCESS;
fail:
pMac->sys.gSysBbtDropped++;
return eSIR_FAILURE;
}
// MAIN LOGIC:
void network_throttle::calculate_times(size_t packet_size, calculate_times_struct &cts, bool dbg, double force_window) const
{
const double the_window_size = std::max( (double)m_window_size ,
((force_window>0) ? force_window : m_window_size)
);
if (!m_any_packet_yet) {
cts.window=0; cts.average=0; cts.delay=0;
cts.recomendetDataSize = m_network_minimal_segment; // should be overrided by caller anyway
return ; // no packet yet, I can not decide about sleep time
}
network_time_seconds window_len = (the_window_size-1) * m_slot_size ; // -1 since current slot is not finished
window_len += (m_last_sample_time - time_to_slot(m_last_sample_time)); // add the time for current slot e.g. 13.7-13 = 0.7
auto time_passed = get_time_seconds() - m_start_time;
cts.window = std::max( std::min( window_len , time_passed ) , m_slot_size ) ; // window length resulting from size of history but limited by how long ago history was started,
// also at least slot size (e.g. 1 second) to not be ridiculous
// window_len e.g. 5.7 because takes into account current slot time
size_t Epast = 0; // summ of traffic till now
for (auto sample : m_history) Epast += sample.m_size;
const size_t E = Epast;
const size_t Enow = Epast + packet_size ; // including the data we're about to send now
const double M = m_target_speed; // max
const double D1 = (Epast - M*cts.window) / M; // delay - how long to sleep to get back to target speed
const double D2 = (Enow - M*cts.window) / M; // delay - how long to sleep to get back to target speed (including current packet)
cts.delay = (D1*0.80 + D2*0.20); // finall sleep depends on both with/without current packet
// update_overheat();
cts.average = Epast/cts.window; // current avg. speed (for info)
if (Epast <= 0) {
if (cts.delay>=0) cts.delay = 0; // no traffic in history so we will not wait
}
double Wgood=-1;
{ // how much data we recommend now to download
Wgood = the_window_size + 1;
cts.recomendetDataSize = M*cts.window - E;
}
if (dbg) {
std::ostringstream oss; oss << "["; for (auto sample: m_history) oss << sample.m_size << " "; oss << "]" << std::ends;
std::string history_str = oss.str();
MTRACE((cts.delay > 0 ? "SLEEP" : "")
<< "dbg " << m_name << ": "
<< "speed is A=" << std::setw(8) <<cts.average<<" vs "
<< "Max=" << std::setw(8) <<M<<" "
<< " so sleep: "
<< "D=" << std::setw(8) <<cts.delay<<" sec "
<< "E="<< std::setw(8) << E << " (Enow="<<std::setw(8)<<Enow<<") "
<< "M=" << std::setw(8) << M <<" W="<< std::setw(8) << cts.window << " "
<< "R=" << std::setw(8) << cts.recomendetDataSize << " Wgood" << std::setw(8) << Wgood << " "
<< "History: " << std::setw(8) << history_str << " "
<< "m_last_sample_time=" << std::setw(8) << m_last_sample_time
);
}
}
/// @fn int s_trnc_state_machine(iow_socket_t *s, app_cfg_t *cfg)
/// @brief state machine implementation
/// @param[in] s iow_socket_t reference
/// @param[in] cfg app_cfg reference
/// @return none
static int s_trnc_state_machine(iow_socket_t *s, app_cfg_t *cfg)
{
int retval=-1;
int scycles=cfg->cycles;
int trn_tx_count=0;
int trn_rx_count=0;
int trn_tx_bytes=0;
int trn_rx_bytes=0;
int trn_msg_count=0;
int trn_msg_bytes=0;
const char *reqstr="REQ\0";
if (NULL!=s) {
// initialize variables
trn_message_t message;
trn_message_t *pmessage = &message;
mbtrn_header_t *pheader = &pmessage->data.header;
mbtrn_sounding_t *psounding = &pmessage->data.sounding;
memset(pmessage,0,sizeof(message));
int hbeat_counter=0;
int64_t test=0;
byte *pread=NULL;
uint32_t readlen=0;
trnc_state_t state=ST_INIT;
trnc_action_t action=AT_NOP;
// state machine entry point
while (state != ST_DONE && !g_interrupt) {
// check states, assign actions
switch (state) {
case ST_INIT:
memset(&message,0,MBTRN_MAX_MSG_BYTES);
action = AT_CONNECT;
break;
case ST_CONNECTED:
action=AT_WR_REQ;
break;
case ST_REQ_PENDING:
case ST_SUBSCRIBED:
memset(&message,0,MBTRN_MAX_MSG_BYTES);
action=AT_RD_MSG;
break;
case ST_HBEAT_EXPIRED:
action=AT_WR_REQ;
break;
default:
break;
}// switch
// action: connect
if (action == AT_CONNECT) {
MMDEBUG(ID_APP,"connecting [%s:%d]\n",cfg->host,cfg->port);
if( (test=iow_connect(s))==0 ) {
MMDEBUG(ID_APP,"connect OK\n");
state=ST_CONNECTED;
}else{
MERROR("connect failed [%"PRId64"]\n",test);
}
}
// action: write request
if (action == AT_WR_REQ) {
test=iow_sendto(s,NULL,(byte *)reqstr,4,0);
MMDEBUG(ID_APP,"sendto REQ ret[%"PRId64"] [%d/%s]\n",test,errno,strerror(errno));
if( test>0 ){
trn_tx_count++;
trn_tx_bytes+=test;
state=ST_REQ_PENDING;
}else{
MMDEBUG(ID_APP,"sendto failed ret[%"PRId64"] [%d/%s]\n",test,errno,strerror(errno));
}
}
// action: read response
if (action == AT_RD_MSG) {
pread = (byte *)&message;
readlen = MBTRN_MAX_MSG_BYTES;
// request message
if ((test = iow_recvfrom(s, NULL, pread, readlen))>0) {
trn_rx_bytes+=test;
trn_rx_count++;
// check message type
if (pheader->type==MBTRN_MSGTYPE_ACK) {
MMDEBUG(ID_APP,"received ACK ret[%"PRId64"] [%08X]\n",test,pheader->type);
hbeat_counter=0;
state=ST_SUBSCRIBED;
}else if (pheader->type==MBTRN_MSGTYPE_MB1) {
MMDEBUG(ID_APP,"received MSG ret[%"PRId64"] type[%08X] size[%d] ping[%06d]\n",test,pheader->type,pheader->size,psounding->ping_number);
trn_msg_count++;
trn_msg_bytes+=test;
action=AT_SHOW_MSG;
if (state==ST_REQ_PENDING) {
state=ST_REQ_PENDING;
}else{
state=ST_SUBSCRIBED;
}
hbeat_counter++;
MMDEBUG(ID_APP,"hbeat[%d/%d]\n",hbeat_counter,cfg->hbeat);
if ( (hbeat_counter!=0) && (hbeat_counter%cfg->hbeat==0)) {
state=ST_HBEAT_EXPIRED;
}
}else{
// response not recognized
MMDEBUG(ID_APP,"invalid message [%08X]\n",pheader->type);
}
}else{
// read returned error
// MMDEBUG(ID_APP,"invalid message [%d]\n",test);
switch (errno) {
case EWOULDBLOCK:
// nothing to read
// MMDEBUG(ID_APP,"err - [%d/%s]\n",errno, strerror(errno));
break;
case ENOTCONN:
case ECONNREFUSED:
// host disconnected
MMDEBUG(ID_APP,"err - server not connected [%d/%s]\n",errno, strerror(errno));
iow_socket_destroy(&s);
s = iow_socket_new(cfg->host, cfg->port, ST_UDP);
iow_set_blocking(s,(cfg->blocking==0?false:true));
sleep(5);
state=ST_INIT;
retval=-1;
break;
default:
MMDEBUG(ID_APP,"err ? [%d/%s]\n",errno, strerror(errno));
break;
}//switch
}
}
// action: show message
if (action == AT_SHOW_MSG) {
MMDEBUG(ID_APP,"\nts[%.3f] ping[%06d] lat[%.4lf] lon[%.4lf]\nsd[%7.2lf] hdg[%6.2lf] nb[%03"PRIu32"]\n",
psounding->ts,
psounding->ping_number,
psounding->lat,
psounding->lon,
psounding->depth,
psounding->hdg,
(uint32_t)psounding->nbeams);
uint32_t j=0;
struct mbtrn_beam_data *bd=psounding->beams;
for (j=0; j<psounding->nbeams; j++,bd++){
MMDEBUG(ID_APP,"n[%03"PRIu32"] atrk/X[% 10.3lf] ctrk/Y[% 10.3lf] dpth/Z[% 10.3lf]\n",
(uint32_t)bd->beam_num,
bd->rhox,
bd->rhoy,
bd->rhoz);
}
}
// action: quit state machine
if (action == AT_QUIT) {
break;
}
// check cycles and signals
scycles--;
if(scycles==0){
MTRACE();
retval=0;
state=ST_DONE;
}
if(g_interrupt){
MTRACE();
retval=-1;
state=ST_DONE;
}
}// while !ST_DONE
}//else invalid arg
MMINFO(ID_APP,"tx count/bytes[%d/%d]\n",trn_tx_count,trn_tx_bytes);
MMINFO(ID_APP,"rx count/bytes[%d/%d]\n",trn_rx_count,trn_rx_bytes);
MMINFO(ID_APP,"trn count/bytes[%d/%d]\n",trn_msg_count,trn_msg_bytes);
return retval;
}
void
lim_process_assoc_rsp_frame(tpAniSirGlobal mac_ctx,
uint8_t *rx_pkt_info, uint8_t subtype, tpPESession session_entry)
{
uint8_t *body;
uint16_t caps, ie_len;
uint32_t frame_len;
tSirMacAddr current_bssid;
tpSirMacMgmtHdr hdr = NULL;
tSirMacCapabilityInfo mac_capab;
tpDphHashNode sta_ds;
tpSirAssocRsp assoc_rsp;
tLimMlmAssocCnf assoc_cnf;
tSchBeaconStruct *beacon;
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
uint8_t sme_sessionid = 0;
#endif
tCsrRoamSession *roam_session;
/* Initialize status code to success. */
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
if (session_entry->bRoamSynchInProgress)
hdr = (tpSirMacMgmtHdr) mac_ctx->roam.pReassocResp;
else
#endif
hdr = WMA_GET_RX_MAC_HEADER(rx_pkt_info);
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
sme_sessionid = session_entry->smeSessionId;
#endif
assoc_cnf.resultCode = eSIR_SME_SUCCESS;
/* Update PE session Id */
assoc_cnf.sessionId = session_entry->peSessionId;
if (hdr == NULL) {
lim_log(mac_ctx, LOGE,
FL("LFR3: Reassoc response packet header is NULL"));
return;
} else if (hdr->sa == NULL) {
lim_log(mac_ctx, LOGE,
FL("LFR3: Reassoc resp packet source address is NULL"));
return;
}
lim_log(mac_ctx, LOG1,
FL("received Re/Assoc(%d) resp on sessionid: %d systemrole: %d"
"and mlmstate: %d RSSI %d from " MAC_ADDRESS_STR), subtype,
session_entry->peSessionId, GET_LIM_SYSTEM_ROLE(session_entry),
session_entry->limMlmState,
(uint) abs((int8_t) WMA_GET_RX_RSSI_DB(rx_pkt_info)),
MAC_ADDR_ARRAY(hdr->sa));
beacon = cdf_mem_malloc(sizeof(tSchBeaconStruct));
if (NULL == beacon) {
lim_log(mac_ctx, LOGE, FL("Unable to allocate memory"));
return;
}
if (LIM_IS_AP_ROLE(session_entry) ||
LIM_IS_BT_AMP_AP_ROLE(session_entry)) {
/*
* Should not have received Re/Association
* Response frame on AP. Log error
*/
lim_log(mac_ctx, LOGE,
FL("Should not recieved Re/Assoc Response in role %d "),
GET_LIM_SYSTEM_ROLE(session_entry));
cdf_mem_free(beacon);
return;
}
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
if (session_entry->bRoamSynchInProgress) {
hdr = (tpSirMacMgmtHdr) mac_ctx->roam.pReassocResp;
frame_len = mac_ctx->roam.reassocRespLen - SIR_MAC_HDR_LEN_3A;
} else {
#endif
hdr = WMA_GET_RX_MAC_HEADER(rx_pkt_info);
frame_len = WMA_GET_RX_PAYLOAD_LEN(rx_pkt_info);
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
}
#endif
if (((subtype == LIM_ASSOC) &&
(session_entry->limMlmState != eLIM_MLM_WT_ASSOC_RSP_STATE)) ||
((subtype == LIM_REASSOC) &&
((session_entry->limMlmState != eLIM_MLM_WT_REASSOC_RSP_STATE)
#if defined (WLAN_FEATURE_VOWIFI_11R) || defined (FEATURE_WLAN_ESE) || defined(FEATURE_WLAN_LFR)
&& (session_entry->limMlmState !=
eLIM_MLM_WT_FT_REASSOC_RSP_STATE)
#endif
))) {
/* Received unexpected Re/Association Response frame */
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
lim_log(mac_ctx, LOG1,
FL("Recieved Re/Assoc rsp in unexpected "
"state %d on session=%d"),
session_entry->limMlmState, session_entry->peSessionId);
#endif
if (!hdr->fc.retry) {
if (!(mac_ctx->lim.retry_packet_cnt & 0xf)) {
lim_log(mac_ctx, LOGE,
FL("recvd Re/Assoc rsp:not a retry frame"));
lim_print_mlm_state(mac_ctx, LOGE,
session_entry->limMlmState);
} else {
mac_ctx->lim.retry_packet_cnt++;
}
}
cdf_mem_free(beacon);
return;
}
sir_copy_mac_addr(current_bssid, session_entry->bssId);
if (subtype == LIM_ASSOC) {
if (!cdf_mem_compare
(hdr->sa, current_bssid, sizeof(tSirMacAddr))) {
/*
* Received Association Response frame from an entity
* other than one to which request was initiated.
* Ignore this and wait until Assoc Failure Timeout
*/
lim_log(mac_ctx, LOGW,
FL("received AssocRsp from unexpected peer "
MAC_ADDRESS_STR),
MAC_ADDR_ARRAY(hdr->sa));
cdf_mem_free(beacon);
return;
}
} else {
if (!cdf_mem_compare
(hdr->sa, session_entry->limReAssocbssId,
sizeof(tSirMacAddr))) {
/*
* Received Reassociation Response frame from an entity
* other than one to which request was initiated.
* Ignore this and wait until Reassoc Failure Timeout.
*/
lim_log(mac_ctx, LOGW,
FL("received ReassocRsp from unexpected peer "
MAC_ADDRESS_STR),
MAC_ADDR_ARRAY(hdr->sa));
cdf_mem_free(beacon);
return;
}
}
assoc_rsp = cdf_mem_malloc(sizeof(*assoc_rsp));
if (NULL == assoc_rsp) {
lim_log(mac_ctx, LOGP,
FL("Allocate Memory failed in AssocRsp"));
cdf_mem_free(beacon);
return;
}
/* Get pointer to Re/Association Response frame body */
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
if (session_entry->bRoamSynchInProgress)
body = mac_ctx->roam.pReassocResp + SIR_MAC_HDR_LEN_3A;
else
#endif
body = WMA_GET_RX_MPDU_DATA(rx_pkt_info);
/* parse Re/Association Response frame. */
if (sir_convert_assoc_resp_frame2_struct(mac_ctx, body,
frame_len, assoc_rsp) == eSIR_FAILURE) {
cdf_mem_free(assoc_rsp);
lim_log(mac_ctx, LOGE,
FL("Parse error Assoc resp subtype %d," "length=%d"),
frame_len, subtype);
cdf_mem_free(beacon);
return;
}
if (!assoc_rsp->suppRatesPresent) {
lim_log(mac_ctx, LOGE,
FL("assoc response does not have supported rate set"));
cdf_mem_copy(&assoc_rsp->supportedRates,
&session_entry->rateSet,
sizeof(tSirMacRateSet));
}
assoc_cnf.protStatusCode = assoc_rsp->statusCode;
if (session_entry->assocRsp != NULL) {
lim_log(mac_ctx, LOGW,
FL("session_entry->assocRsp is not NULL freeing it "
"and setting NULL"));
cdf_mem_free(session_entry->assocRsp);
session_entry->assocRsp = NULL;
}
session_entry->assocRsp = cdf_mem_malloc(frame_len);
if (NULL == session_entry->assocRsp) {
lim_log(mac_ctx, LOGE,
FL("Unable to allocate memory for assoc res,len=%d"),
frame_len);
} else {
/*
* Store the Assoc response. This is sent
* to csr/hdd in join cnf response.
*/
cdf_mem_copy(session_entry->assocRsp, body, frame_len);
session_entry->assocRspLen = frame_len;
}
#ifdef WLAN_FEATURE_VOWIFI_11R
lim_update_ric_data(mac_ctx, session_entry, assoc_rsp);
#endif
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
roam_session =
&mac_ctx->roam.roamSession[sme_sessionid];
if (assoc_rsp->FTInfo.R0KH_ID.present) {
roam_session->ftSmeContext.r0kh_id_len =
assoc_rsp->FTInfo.R0KH_ID.num_PMK_R0_ID;
cdf_mem_copy(roam_session->ftSmeContext.r0kh_id,
assoc_rsp->FTInfo.R0KH_ID.PMK_R0_ID,
roam_session->ftSmeContext.r0kh_id_len);
} else {
roam_session->ftSmeContext.r0kh_id_len = 0;
cdf_mem_zero(roam_session->ftSmeContext.r0kh_id,
SIR_ROAM_R0KH_ID_MAX_LEN);
}
#endif
#ifdef FEATURE_WLAN_ESE
lim_update_ese_tspec(mac_ctx, session_entry, assoc_rsp);
#endif
if (assoc_rsp->capabilityInfo.ibss) {
/*
* Received Re/Association Response from peer
* with IBSS capability set.
* Ignore the frame and wait until Re/assoc
* failure timeout.
*/
lim_log(mac_ctx, LOGE,
FL("received Re/AssocRsp frame with IBSS capability"));
cdf_mem_free(assoc_rsp);
cdf_mem_free(beacon);
return;
}
if (cfg_get_capability_info(mac_ctx, &caps, session_entry)
!= eSIR_SUCCESS) {
cdf_mem_free(assoc_rsp);
cdf_mem_free(beacon);
lim_log(mac_ctx, LOGP, FL("could not retrieve Capabilities "));
return;
}
lim_copy_u16((uint8_t *) &mac_capab, caps);
/* Stop Association failure timer */
if (subtype == LIM_ASSOC)
lim_deactivate_and_change_timer(mac_ctx, eLIM_ASSOC_FAIL_TIMER);
else
{
/* Stop Reassociation failure timer */
#if defined (WLAN_FEATURE_VOWIFI_11R) || defined (FEATURE_WLAN_ESE) || defined(FEATURE_WLAN_LFR)
mac_ctx->lim.reAssocRetryAttempt = 0;
if ((NULL != mac_ctx->lim.pSessionEntry)
&& (NULL !=
mac_ctx->lim.pSessionEntry->pLimMlmReassocRetryReq)) {
cdf_mem_free(
mac_ctx->lim.pSessionEntry->pLimMlmReassocRetryReq);
mac_ctx->lim.pSessionEntry->pLimMlmReassocRetryReq =
NULL;
}
#endif
lim_deactivate_and_change_timer(mac_ctx,
eLIM_REASSOC_FAIL_TIMER);
}
if (assoc_rsp->statusCode != eSIR_MAC_SUCCESS_STATUS
#ifdef WLAN_FEATURE_11W
&& (session_entry->limRmfEnabled ||
assoc_rsp->statusCode != eSIR_MAC_TRY_AGAIN_LATER)
#endif
) {
/*
*Re/Association response was received
* either with failure code.
*/
lim_log(mac_ctx, LOGE,
FL("received Re/AssocRsp frame failure code %d"),
assoc_rsp->statusCode);
/*
* Need to update 'association failure' error counter
* along with STATUS CODE
* Return Assoc confirm to SME with received failure code
*/
assoc_cnf.resultCode = eSIR_SME_ASSOC_REFUSED;
/* Delete Pre-auth context for the associated BSS */
if (lim_search_pre_auth_list(mac_ctx, hdr->sa))
lim_delete_pre_auth_node(mac_ctx, hdr->sa);
goto assocReject;
} else if ((assoc_rsp->aid & 0x3FFF) > 2007) {
/*
* Re/Association response was received
* with invalid AID value
*/
lim_log(mac_ctx, LOGE, FL("received Re/AssocRsp frame with"
"invalid aid %X"), assoc_rsp->aid);
assoc_cnf.resultCode = eSIR_SME_INVALID_ASSOC_RSP_RXED;
assoc_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS;
/* Send advisory Disassociation frame to AP */
lim_send_disassoc_mgmt_frame(mac_ctx,
eSIR_MAC_UNSPEC_FAILURE_REASON,
hdr->sa, session_entry, false);
goto assocReject;
}
/*
* Association Response received with success code
* Set the link state to POSTASSOC now that we have received
* assoc/reassoc response
* NOTE: for BTAMP case, it is being handled in
* lim_process_mlm_assoc_req
*/
#ifdef WLAN_FEATURE_11W
if (session_entry->limRmfEnabled &&
assoc_rsp->statusCode == eSIR_MAC_TRY_AGAIN_LATER) {
if (assoc_rsp->TimeoutInterval.present &&
(assoc_rsp->TimeoutInterval.timeoutType ==
SIR_MAC_TI_TYPE_ASSOC_COMEBACK)) {
uint16_t timeout_value =
assoc_rsp->TimeoutInterval.timeoutValue;
if (timeout_value < 10) {
/*
* if this value is less than 10 then our timer
* will fail to start and due to this we will
* never re-attempt. Better modify the timer
* value here.
*/
timeout_value = 10;
}
lim_log(mac_ctx, LOG1,
FL("ASSOC res with eSIR_MAC_TRY_AGAIN_LATER "
" recvd.Starting timer to wait timeout=%d."),
timeout_value);
if (CDF_STATUS_SUCCESS !=
cdf_mc_timer_start(
&session_entry->pmfComebackTimer,
timeout_value)) {
lim_log(mac_ctx, LOGE,
FL("Failed to start comeback timer."));
}
} else {
lim_log(mac_ctx, LOGW,
FL("ASSOC resp with try again event recvd. "
"But try again time interval IE is wrong."));
}
cdf_mem_free(beacon);
cdf_mem_free(assoc_rsp);
return;
}
#endif
if (!((session_entry->bssType == eSIR_BTAMP_STA_MODE) ||
((session_entry->bssType == eSIR_BTAMP_AP_MODE) &&
LIM_IS_BT_AMP_STA_ROLE(session_entry)))) {
if (lim_set_link_state
(mac_ctx, eSIR_LINK_POSTASSOC_STATE,
session_entry->bssId,
session_entry->selfMacAddr, NULL,
NULL) != eSIR_SUCCESS) {
lim_log(mac_ctx, LOGE,
FL("Set link state to POSTASSOC failed"));
cdf_mem_free(beacon);
cdf_mem_free(assoc_rsp);
return;
}
}
if (subtype == LIM_REASSOC) {
lim_log
(mac_ctx, LOG1, FL("Successfully Reassociated with BSS"));
#ifdef FEATURE_WLAN_DIAG_SUPPORT
lim_diag_event_report(mac_ctx, WLAN_PE_DIAG_ROAM_ASSOC_COMP_EVENT,
session_entry, eSIR_SUCCESS, eSIR_SUCCESS);
#endif
#ifdef FEATURE_WLAN_ESE
if (assoc_rsp->tsmPresent)
lim_update_ese_tsm(mac_ctx, session_entry, assoc_rsp);
#endif
if (session_entry->pLimMlmJoinReq) {
cdf_mem_free(session_entry->pLimMlmJoinReq);
session_entry->pLimMlmJoinReq = NULL;
}
session_entry->limAssocResponseData = (void *)assoc_rsp;
/*
* Store the ReAssocRsp Frame in DphTable
* to be used during processing DelSta and
* DelBss to send AddBss again
*/
sta_ds =
dph_get_hash_entry(mac_ctx, DPH_STA_HASH_INDEX_PEER,
&session_entry->dph.dphHashTable);
if (!sta_ds) {
lim_log(mac_ctx, LOGE,
FL("could not get hash entry at DPH for"));
lim_print_mac_addr(mac_ctx, hdr->sa, LOGE);
assoc_cnf.resultCode =
eSIR_SME_INVALID_ASSOC_RSP_RXED;
assoc_cnf.protStatusCode =
eSIR_MAC_UNSPEC_FAILURE_STATUS;
/* Send advisory Disassociation frame to AP */
lim_send_disassoc_mgmt_frame(mac_ctx,
eSIR_MAC_UNSPEC_FAILURE_REASON, hdr->sa,
session_entry, false);
goto assocReject;
}
#if defined(WLAN_FEATURE_VOWIFI_11R) || defined (FEATURE_WLAN_ESE) || defined(FEATURE_WLAN_LFR)
if (session_entry->limMlmState ==
eLIM_MLM_WT_FT_REASSOC_RSP_STATE) {
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
lim_log(mac_ctx, LOG1, FL("Sending self sta"));
#endif
lim_update_assoc_sta_datas(mac_ctx, sta_ds, assoc_rsp,
session_entry);
/* Store assigned AID for TIM processing */
session_entry->limAID = assoc_rsp->aid & 0x3FFF;
/* Downgrade the EDCA parameters if needed */
lim_set_active_edca_params(mac_ctx,
session_entry->gLimEdcaParams,
session_entry);
/* Send the active EDCA parameters to HAL */
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
if (!session_entry->bRoamSynchInProgress) {
#endif
lim_send_edca_params(mac_ctx,
session_entry->gLimEdcaParamsActive,
sta_ds->bssId);
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
}
#endif
lim_add_ft_sta_self(mac_ctx, (assoc_rsp->aid & 0x3FFF),
session_entry);
cdf_mem_free(beacon);
return;
}
#endif /* WLAN_FEATURE_VOWIFI_11R */
/*
* If we're re-associating to the same BSS,
* we don't want to invoke delete STA, delete
* BSS, as that would remove the already
* established TSPEC. Just go ahead and re-add
* the BSS, STA with new capability information.
* However, if we're re-associating to a different
* BSS, then follow thru with del STA, del BSS,
* add BSS, add STA.
*/
if (sir_compare_mac_addr(session_entry->bssId,
session_entry->limReAssocbssId))
lim_handle_add_bss_in_re_assoc_context(mac_ctx, sta_ds,
session_entry);
else {
/*
* reset the uapsd mask settings since
* we're re-associating to new AP
*/
session_entry->gUapsdPerAcDeliveryEnableMask = 0;
session_entry->gUapsdPerAcTriggerEnableMask = 0;
if (lim_cleanup_rx_path(mac_ctx, sta_ds, session_entry)
!= eSIR_SUCCESS) {
lim_log(mac_ctx, LOGE,
FL("Could not cleanup the rx path"));
goto assocReject;
}
}
cdf_mem_free(beacon);
return;
}
lim_log(mac_ctx, LOG1,
FL("Successfully Associated with BSS " MAC_ADDRESS_STR),
MAC_ADDR_ARRAY(hdr->sa));
#ifdef FEATURE_WLAN_ESE
if (session_entry->eseContext.tsm.tsmInfo.state)
session_entry->eseContext.tsm.tsmMetrics.RoamingCount = 0;
#endif
/* Store assigned AID for TIM processing */
session_entry->limAID = assoc_rsp->aid & 0x3FFF;
/* STA entry was created during pre-assoc state. */
sta_ds = dph_get_hash_entry(mac_ctx, DPH_STA_HASH_INDEX_PEER,
&session_entry->dph.dphHashTable);
if (sta_ds == NULL) {
/* Could not add hash table entry */
lim_log(mac_ctx, LOGE, FL("could not get hash entry at DPH "));
lim_print_mac_addr(mac_ctx, hdr->sa, LOGE);
assoc_cnf.resultCode = eSIR_SME_RESOURCES_UNAVAILABLE;
assoc_cnf.protStatusCode = eSIR_SME_SUCCESS;
lim_post_sme_message(mac_ctx, LIM_MLM_ASSOC_CNF,
(uint32_t *) &assoc_cnf);
cdf_mem_free(assoc_rsp);
cdf_mem_free(beacon);
return;
}
/* Delete Pre-auth context for the associated BSS */
if (lim_search_pre_auth_list(mac_ctx, hdr->sa))
lim_delete_pre_auth_node(mac_ctx, hdr->sa);
lim_update_assoc_sta_datas(mac_ctx, sta_ds, assoc_rsp, session_entry);
/*
* Extract the AP capabilities from the beacon that
* was received earlier
*/
ie_len = lim_get_ielen_from_bss_description(
&session_entry->pLimJoinReq->bssDescription);
lim_extract_ap_capabilities(mac_ctx,
(uint8_t *) session_entry->pLimJoinReq->bssDescription.ieFields,
ie_len,
beacon);
if (mac_ctx->lim.gLimProtectionControl !=
WNI_CFG_FORCE_POLICY_PROTECTION_DISABLE)
lim_decide_sta_protection_on_assoc(mac_ctx, beacon,
session_entry);
if (beacon->erpPresent) {
if (beacon->erpIEInfo.barkerPreambleMode)
session_entry->beaconParams.fShortPreamble = false;
else
session_entry->beaconParams.fShortPreamble = true;
}
#ifdef FEATURE_WLAN_DIAG_SUPPORT
lim_diag_event_report(mac_ctx, WLAN_PE_DIAG_CONNECTED, session_entry,
eSIR_SUCCESS, eSIR_SUCCESS);
#endif
if (assoc_rsp->QosMapSet.present)
cdf_mem_copy(&session_entry->QosMapSet,
&assoc_rsp->QosMapSet, sizeof(tSirQosMapSet));
else
cdf_mem_zero(&session_entry->QosMapSet, sizeof(tSirQosMapSet));
lim_update_stads_ext_cap(mac_ctx, session_entry, assoc_rsp, sta_ds);
/* Update the BSS Entry, this entry was added during preassoc. */
if (eSIR_SUCCESS == lim_sta_send_add_bss(mac_ctx, assoc_rsp,
beacon,
&session_entry->pLimJoinReq->bssDescription, true,
session_entry)) {
cdf_mem_free(assoc_rsp);
cdf_mem_free(beacon);
return;
} else {
lim_log(mac_ctx, LOGE, FL("could not update the bss entry"));
assoc_cnf.resultCode = eSIR_SME_RESOURCES_UNAVAILABLE;
assoc_cnf.protStatusCode = eSIR_MAC_UNSPEC_FAILURE_STATUS;
}
assocReject:
if ((subtype == LIM_ASSOC)
#ifdef WLAN_FEATURE_VOWIFI_11R
|| ((subtype == LIM_REASSOC)
&& (session_entry->limMlmState ==
eLIM_MLM_WT_FT_REASSOC_RSP_STATE))
#endif
) {
lim_log(mac_ctx, LOGE, FL("Assoc Rejected by the peer. "
"mlmestate: %d sessionid %d Reason: %d MACADDR:"
MAC_ADDRESS_STR),
session_entry->limMlmState,
session_entry->peSessionId,
assoc_cnf.resultCode, MAC_ADDR_ARRAY(hdr->sa));
session_entry->limMlmState = eLIM_MLM_IDLE_STATE;
MTRACE(mac_trace(mac_ctx, TRACE_CODE_MLM_STATE,
session_entry->peSessionId,
session_entry->limMlmState));
if (session_entry->pLimMlmJoinReq) {
cdf_mem_free(session_entry->pLimMlmJoinReq);
session_entry->pLimMlmJoinReq = NULL;
}
if (subtype == LIM_ASSOC) {
lim_post_sme_message(mac_ctx, LIM_MLM_ASSOC_CNF,
(uint32_t *) &assoc_cnf);
}
#ifdef WLAN_FEATURE_VOWIFI_11R
else {
assoc_cnf.resultCode = eSIR_SME_FT_REASSOC_FAILURE;
lim_post_sme_message(mac_ctx, LIM_MLM_REASSOC_CNF,
(uint32_t *)&assoc_cnf);
}
#endif
} else {
lim_restore_pre_reassoc_state(mac_ctx,
eSIR_SME_REASSOC_REFUSED,
assoc_cnf.protStatusCode,
session_entry);
}
cdf_mem_free(beacon);
cdf_mem_free(assoc_rsp);
return;
}
