/* * Copyright (c) 2012-2019 The Linux Foundation. All rights reserved. * * Previously licensed under the ISC license by Qualcomm Atheros, Inc. * * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the * above copyright notice and this permission notice appear in all * copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ /* * This file was originally distributed by Qualcomm Atheros, Inc. * under proprietary terms before Copyright ownership was assigned * to the Linux Foundation. */ /**======================================================================== \file wlan_hdd_scan.c \brief WLAN Host Device Driver implementation ========================================================================*/ /**========================================================================= EDIT HISTORY FOR FILE This section contains comments describing changes made to the module. Notice that changes are listed in reverse chronological order. $Header:$ $DateTime: $ $Author: $ when who what, where, why -------- --- -------------------------------------------------------- 04/5/09 Shailender Created module. ==========================================================================*/ /* To extract the Scan results */ /* Add a stream event */ #include #include #include #include #include #include #ifdef WLAN_BTAMP_FEATURE #include "bap_hdd_misc.h" #endif #include #include #include #define WEXT_CSCAN_HEADER "CSCAN S\x01\x00\x00S\x00" #define WEXT_CSCAN_HEADER_SIZE 12 #define WEXT_CSCAN_SSID_SECTION 'S' #define WEXT_CSCAN_CHANNEL_SECTION 'C' #define WEXT_CSCAN_NPROBE_SECTION 'N' #define WEXT_CSCAN_ACTV_DWELL_SECTION 'A' #define WEXT_CSCAN_PASV_DWELL_SECTION 'P' #define WEXT_CSCAN_HOME_DWELL_SECTION 'H' #define WEXT_CSCAN_TYPE_SECTION 'T' #define WEXT_CSCAN_PENDING_SECTION 'O' #define WEXT_CSCAN_TYPE_DEFAULT 0 #define WEXT_CSCAN_TYPE_PASSIVE 1 #define WEXT_CSCAN_PASV_DWELL_TIME 130 #define WEXT_CSCAN_PASV_DWELL_TIME_DEF 250 #define WEXT_CSCAN_PASV_DWELL_TIME_MAX 3000 #define WEXT_CSCAN_HOME_DWELL_TIME 130 #define MAX_RATES 12 #define WEXT_CSCAN_SCAN_DONE_WAIT_TIME 2000 typedef struct hdd_scan_info{ struct net_device *dev; struct iw_request_info *info; char *start; char *end; } hdd_scan_info_t, *hdd_scan_info_tp; static v_S31_t hdd_TranslateABGRateToMbpsRate(v_U8_t *pFcRate) { /** Slightly more sophisticated processing has to take place here. Basic rates are rounded DOWN. HT rates are rounded UP.*/ return ( (( ((v_S31_t) *pFcRate) & 0x007f) * 1000000) / 2); } static eHalStatus hdd_AddIwStreamEvent(int cmd, int length, char* data, hdd_scan_info_t *pscanInfo, char **last_event, char **current_event ) { struct iw_event event; *last_event = *current_event; vos_mem_zero(&event, sizeof (struct iw_event)); event.cmd = cmd; event.u.data.flags = 1; event.u.data.length = length; *current_event = iwe_stream_add_point (pscanInfo->info,*current_event, pscanInfo->end, &event, data); if(*last_event == *current_event) { /* no space to add event */ hddLog( LOGW, "%s: no space left to add event", __func__); return -E2BIG; /* Error code, may be E2BIG */ } return 0; } /**--------------------------------------------------------------------------- \brief hdd_GetWPARSNIEs() - This function extract the WPA/RSN IE from the Bss descriptor IEs fields \param - ieFields - Pointer to the Bss Descriptor IEs. - ie_length - IE Length. - last_event -Points to the last event. - current_event - Points to the \return - 0 for success, non zero for failure --------------------------------------------------------------------------*/ /* Extract the WPA and/or RSN IEs */ static eHalStatus hdd_GetWPARSNIEs( v_U8_t *ieFields, v_U16_t ie_length, char **last_event, char **current_event, hdd_scan_info_t *pscanInfo ) { v_U8_t eid, elen, *element; v_U16_t tie_length=0; ENTER(); element = ieFields; tie_length = ie_length; while( tie_length > 2 && element != NULL ) { eid = element[0]; elen = element[1]; /*If element length is greater than total remaining ie length, *break the loop*/ if ((elen+2) > tie_length) break; switch(eid) { case DOT11F_EID_WPA: case DOT11F_EID_RSN: #ifdef FEATURE_WLAN_WAPI case DOT11F_EID_WAPI: #endif if(hdd_AddIwStreamEvent( IWEVGENIE, elen+2, (char*)element, pscanInfo, last_event, current_event ) < 0 ) return -E2BIG; break; default: break; } /* Next element */ tie_length -= (2 + elen); element += 2 + elen; } return 0; } /**--------------------------------------------------------------------------- \brief hdd_IndicateScanResult() - This function returns the scan results to the wpa_supplicant \param - scanInfo - Pointer to the scan info structure. - descriptor - Pointer to the Bss Descriptor. \return - 0 for success, non zero for failure --------------------------------------------------------------------------*/ #define MAX_CUSTOM_LEN 64 static eHalStatus hdd_IndicateScanResult(hdd_scan_info_t *scanInfo, tCsrScanResultInfo *scan_result) { hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(scanInfo->dev) ; tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter); tSirBssDescription *descriptor = &scan_result->BssDescriptor; struct iw_event event; char *current_event = scanInfo->start; char *end = scanInfo->end; char *last_event; char *current_pad; v_U16_t ie_length = 0; v_U16_t capabilityInfo; char *modestr; int error; char custom[MAX_CUSTOM_LEN]; char *p; tANI_U32 status; hddLog( LOG1, "hdd_IndicateScanResult " MAC_ADDRESS_STR, MAC_ADDR_ARRAY(descriptor->bssId)); error = 0; last_event = current_event; vos_mem_zero(&event, sizeof (event)); /* BSSID */ event.cmd = SIOCGIWAP; event.u.ap_addr.sa_family = ARPHRD_ETHER; vos_mem_copy (event.u.ap_addr.sa_data, descriptor->bssId, sizeof (descriptor->bssId)); current_event = iwe_stream_add_event(scanInfo->info,current_event, end, &event, IW_EV_ADDR_LEN); if (last_event == current_event) { /* no space to add event */ /* Error code may be E2BIG */ hddLog(LOGE, "hdd_IndicateScanResult: no space for SIOCGIWAP "); return -E2BIG; } last_event = current_event; vos_mem_zero(&event, sizeof (struct iw_event)); /* Protocol Name */ event.cmd = SIOCGIWNAME; switch (descriptor->nwType) { case eSIR_11A_NW_TYPE: modestr = "a"; break; case eSIR_11B_NW_TYPE: modestr = "b"; break; case eSIR_11G_NW_TYPE: modestr = "g"; break; case eSIR_11N_NW_TYPE: modestr = "n"; break; default: hddLog( LOGW, "%s: Unknown network type [%d]", __func__, descriptor->nwType); modestr = "?"; break; } snprintf(event.u.name, IFNAMSIZ, "IEEE 802.11%s", modestr); current_event = iwe_stream_add_event(scanInfo->info,current_event, end, &event, IW_EV_CHAR_LEN); if (last_event == current_event) { /* no space to add event */ hddLog( LOGE, "hdd_IndicateScanResult: no space for SIOCGIWNAME"); /* Error code, may be E2BIG */ return -E2BIG; } last_event = current_event; vos_mem_zero( &event, sizeof (struct iw_event)); /*Freq*/ event.cmd = SIOCGIWFREQ; event.u.freq.m = descriptor->channelId; event.u.freq.e = 0; event.u.freq.i = 0; current_event = iwe_stream_add_event(scanInfo->info,current_event, end, &event, IW_EV_FREQ_LEN); if (last_event == current_event) { /* no space to add event */ hddLog( LOGE, "hdd_IndicateScanResult: no space for SIOCGIWFREQ"); return -E2BIG; } last_event = current_event; vos_mem_zero( &event, sizeof (struct iw_event)); /* BSS Mode */ event.cmd = SIOCGIWMODE; capabilityInfo = descriptor->capabilityInfo; if (SIR_MAC_GET_ESS(capabilityInfo)) { event.u.mode = IW_MODE_INFRA; } else if (SIR_MAC_GET_IBSS(capabilityInfo)) { event.u.mode = IW_MODE_ADHOC; } else { /* neither ESS or IBSS */ event.u.mode = IW_MODE_AUTO; } current_event = iwe_stream_add_event(scanInfo->info,current_event, end, &event, IW_EV_UINT_LEN); if (last_event == current_event) { /* no space to add event */ hddLog(LOGE, "hdd_IndicateScanResult: no space for SIOCGIWMODE"); return -E2BIG; } /* To extract SSID */ ie_length = GET_IE_LEN_IN_BSS( descriptor->length ); if (ie_length > 0) { /* dot11BeaconIEs is a large struct, so we make it static to avoid stack overflow. This API is only invoked via ioctl, so it is serialized by the kernel rtnl_lock and hence does not need to be reentrant */ static tDot11fBeaconIEs dot11BeaconIEs; tDot11fIESSID *pDot11SSID; tDot11fIESuppRates *pDot11SuppRates; tDot11fIEExtSuppRates *pDot11ExtSuppRates; tDot11fIEHTCaps *pDot11IEHTCaps; int numBasicRates = 0; int maxNumRates = 0; pDot11IEHTCaps = NULL; status = dot11fUnpackBeaconIEs ((tpAniSirGlobal) hHal, (tANI_U8 *) descriptor->ieFields, ie_length, &dot11BeaconIEs); if (DOT11F_FAILED(status)) { hddLog(LOGE, FL("unpack failed for Beacon IE status:(0x%08x)"), status); return -EINVAL; } pDot11SSID = &dot11BeaconIEs.SSID; if (pDot11SSID->present ) { last_event = current_event; vos_mem_zero (&event, sizeof (struct iw_event)); event.cmd = SIOCGIWESSID; event.u.data.flags = 1; event.u.data.length = scan_result->ssId.length; current_event = iwe_stream_add_point (scanInfo->info,current_event, end, &event, (char *)scan_result->ssId.ssId); if(last_event == current_event) { /* no space to add event */ hddLog( LOGE, "hdd_IndicateScanResult: no space for SIOCGIWESSID"); return -E2BIG; } } if( hdd_GetWPARSNIEs( ( tANI_U8 *) descriptor->ieFields, ie_length, &last_event, ¤t_event, scanInfo ) < 0 ) { hddLog( LOGE, "hdd_IndicateScanResult: no space for SIOCGIWESSID"); return -E2BIG; } last_event = current_event; current_pad = current_event + IW_EV_LCP_LEN; vos_mem_zero( &event, sizeof (struct iw_event)); /*Rates*/ event.cmd = SIOCGIWRATE; pDot11SuppRates = &dot11BeaconIEs.SuppRates; if (pDot11SuppRates->present ) { int i; numBasicRates = pDot11SuppRates->num_rates; for (i=0; inum_rates; i++) { if (0 != (pDot11SuppRates->rates[i] & 0x7F)) { event.u.bitrate.value = hdd_TranslateABGRateToMbpsRate ( &pDot11SuppRates->rates[i]); current_pad = iwe_stream_add_value (scanInfo->info,current_event, current_pad, end, &event, IW_EV_PARAM_LEN); } } } pDot11ExtSuppRates = &dot11BeaconIEs.ExtSuppRates; if (pDot11ExtSuppRates->present ) { int i,no_of_rates; maxNumRates = numBasicRates + pDot11ExtSuppRates->num_rates; /* Check to make sure the total number of rates doesn't exceed IW_MAX_BITRATES */ maxNumRates = VOS_MIN(maxNumRates , IW_MAX_BITRATES); if((maxNumRates - numBasicRates) > MAX_RATES) { no_of_rates = MAX_RATES; hddLog( LOGW, "Accessing array out of bound that array is pDot11ExtSuppRates->rates "); } else { no_of_rates = maxNumRates - numBasicRates; } for ( i=0; i< no_of_rates ; i++ ) { if (0 != (pDot11ExtSuppRates->rates[i] & 0x7F)) { event.u.bitrate.value = hdd_TranslateABGRateToMbpsRate ( &pDot11ExtSuppRates->rates[i]); current_pad = iwe_stream_add_value (scanInfo->info,current_event, current_pad, end, &event, IW_EV_PARAM_LEN); } } } if ((current_pad - current_event) >= IW_EV_LCP_LEN) { current_event = current_pad; } else { if (last_event == current_event) { /* no space to add event */ hddLog( LOGE, "hdd_IndicateScanResult: no space for SIOCGIWRATE"); return -E2BIG; } } last_event = current_event; vos_mem_zero (&event, sizeof (struct iw_event)); event.cmd = SIOCGIWENCODE; if (SIR_MAC_GET_PRIVACY(capabilityInfo)) { event.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; } else { event.u.data.flags = IW_ENCODE_DISABLED; } event.u.data.length = 0; current_event = iwe_stream_add_point(scanInfo->info,current_event, end, &event, (char *)pDot11SSID->ssid); if(last_event == current_event) { /* no space to add event Error code, may be E2BIG */ hddLog( LOGE, "hdd_IndicateScanResult: no space for SIOCGIWENCODE"); return -E2BIG; } } last_event = current_event; vos_mem_zero( &event, sizeof (struct iw_event)); /*RSSI*/ event.cmd = IWEVQUAL; event.u.qual.qual = descriptor->rssi; event.u.qual.noise = descriptor->sinr; /*To keep the rssi icon of the connected AP in the scan window *and the rssi icon of the wireless networks in sync */ if (( eConnectionState_Associated == pAdapter->sessionCtx.station.conn_info.connState ) && ( VOS_TRUE == vos_mem_compare(descriptor->bssId, pAdapter->sessionCtx.station.conn_info.bssId, WNI_CFG_BSSID_LEN))) { event.u.qual.level = pAdapter->rssi; } else { event.u.qual.level = VOS_MIN ((descriptor->rssi + descriptor->sinr), 0); } event.u.qual.updated = IW_QUAL_ALL_UPDATED; current_event = iwe_stream_add_event(scanInfo->info,current_event, end, &event, IW_EV_QUAL_LEN); if(last_event == current_event) { /* no space to add event */ hddLog( LOGE, "hdd_IndicateScanResult: no space for IWEVQUAL"); return -E2BIG; } /* AGE */ event.cmd = IWEVCUSTOM; p = custom; p += scnprintf(p, MAX_CUSTOM_LEN, " Age: %lu", vos_timer_get_system_time() - descriptor->nReceivedTime); event.u.data.length = p - custom; current_event = iwe_stream_add_point (scanInfo->info,current_event, end, &event, custom); if(last_event == current_event) { /* no space to add event */ hddLog( LOGE, "hdd_IndicateScanResult: no space for IWEVCUSTOM (age)"); return -E2BIG; } scanInfo->start = current_event; return 0; } /**--------------------------------------------------------------------------- \brief hdd_processSpoofMacAddrRequest() - The function is called from scan completion callback and from cfg80211 vendor command \param - pHddCtx - Pointer to the HDD Context. \return - 0 for success, non zero for failure --------------------------------------------------------------------------*/ void __hdd_processSpoofMacAddrRequest(struct work_struct *work) { hdd_context_t *pHddCtx = container_of(to_delayed_work(work), hdd_context_t, spoof_mac_addr_work); ENTER(); if (wlan_hdd_validate_context(pHddCtx)) return; mutex_lock(&pHddCtx->spoofMacAddr.macSpoofingLock); if (pHddCtx->spoofMacAddr.isEnabled) { if (VOS_STATUS_SUCCESS != vos_randomize_n_bytes( (void *)(&pHddCtx->spoofMacAddr.randomMacAddr.bytes[3]), VOS_MAC_ADDR_LAST_3_BYTES)) { pHddCtx->spoofMacAddr.isEnabled = FALSE; mutex_unlock(&pHddCtx->spoofMacAddr.macSpoofingLock); hddLog(LOGE, FL("Failed to generate random Mac Addr")); return; } } hddLog(LOG1, FL("New Mac Addr Generated "MAC_ADDRESS_STR), MAC_ADDR_ARRAY(pHddCtx->spoofMacAddr.randomMacAddr.bytes)); if (pHddCtx->scan_info.mScanPending != TRUE) { pHddCtx->spoofMacAddr.isReqDeferred = FALSE; hddLog(LOG1, FL("Processing Spoof request now")); /* Inform SME about spoof mac addr request*/ if ( eHAL_STATUS_SUCCESS != sme_SpoofMacAddrReq(pHddCtx->hHal, &pHddCtx->spoofMacAddr.randomMacAddr, true)) { hddLog(LOGE, FL("Sending Spoof request failed - Disable spoofing")); pHddCtx->spoofMacAddr.isEnabled = FALSE; } } else { hddLog(LOG1, FL("Scan in Progress. Spoofing Deferred")); pHddCtx->spoofMacAddr.isReqDeferred = TRUE; } mutex_unlock(&pHddCtx->spoofMacAddr.macSpoofingLock); EXIT(); return; } void hdd_processSpoofMacAddrRequest(struct work_struct *work) { vos_ssr_protect(__func__); __hdd_processSpoofMacAddrRequest(work); vos_ssr_unprotect(__func__); } /**--------------------------------------------------------------------------- \brief hdd_ScanRequestCallback() - The sme module calls this callback function once it finish the scan request and this function notifies the scan complete event to the wpa_supplicant. \param - halHandle - Pointer to the Hal Handle. - pContext - Pointer to the data context. - scanId - Scan ID. - status - CSR Status. \return - 0 for success, non zero for failure --------------------------------------------------------------------------*/ static eHalStatus hdd_ScanRequestCallback(tHalHandle halHandle, void *pContext, tANI_U32 scanId, eCsrScanStatus status) { struct net_device *dev = (struct net_device *) pContext; hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev) ; hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter); union iwreq_data wrqu; int we_event; char *msg; ENTER(); hddLog(LOGW,"%s called with halHandle = %pK, pContext = %pK, scanID = %d," " returned status = %d", __func__, halHandle, pContext, (int) scanId, (int) status); /* if there is a scan request pending when the wlan driver is unloaded we may be invoked as SME flushes its pending queue. If that is the case, the underlying net_device may have already been destroyed, so do some quick sanity before proceeding */ if (pAdapter->dev != dev) { hddLog(LOGW, "%s: device mismatch %pK vs %pK", __func__, pAdapter->dev, dev); return eHAL_STATUS_SUCCESS; } /* Check the scanId */ if (pHddCtx->scan_info.scanId != scanId) { hddLog(LOGW, "%s called with mismatched scanId pHddCtx->scan_info.scanId = %d " "scanId = %d ", __func__, (int) pHddCtx->scan_info.scanId, (int) scanId); } /* Scan is no longer pending */ pHddCtx->scan_info.mScanPending = VOS_FALSE; // notify any applications that may be interested memset(&wrqu, '\0', sizeof(wrqu)); we_event = SIOCGIWSCAN; msg = NULL; wireless_send_event(dev, we_event, &wrqu, msg); EXIT(); VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: exit !!!",__func__); return eHAL_STATUS_SUCCESS; } /**--------------------------------------------------------------------------- \brief __iw_set_scan() - This function process the scan request from the wpa_supplicant and set the scan request to the SME \param - dev - Pointer to the net device. - info - Pointer to the iw_request_info. - wrqu - Pointer to the iwreq_data. - extra - Pointer to the data. \return - 0 for success, non zero for failure --------------------------------------------------------------------------*/ int __iw_set_scan(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { hdd_adapter_t *pAdapter; hdd_context_t *pHddCtx; hdd_wext_state_t *pwextBuf; tCsrScanRequest scanRequest; v_U32_t scanId = 0; eHalStatus status = eHAL_STATUS_SUCCESS; struct iw_scan_req *scanReq = (struct iw_scan_req *)extra; int ret = 0; ENTER(); VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: enter !!!",__func__); pAdapter = WLAN_HDD_GET_PRIV_PTR(dev); if (NULL == pAdapter) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: Adapter is NULL",__func__); return -EINVAL; } pHddCtx = WLAN_HDD_GET_CTX(pAdapter); ret = wlan_hdd_validate_context(pHddCtx); if (0 != ret) { return ret; } pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter); if (NULL == pwextBuf) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: pwextBuf is NULL",__func__); return -EINVAL; } #ifdef WLAN_BTAMP_FEATURE //Scan not supported when AMP traffic is on. if( VOS_TRUE == WLANBAP_AmpSessionOn() ) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: No scanning when AMP is on",__func__); return eHAL_STATUS_SUCCESS; } #endif if(pHddCtx->scan_info.mScanPending == TRUE) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s:mScanPending is TRUE !!!",__func__); return eHAL_STATUS_SUCCESS; } vos_mem_zero( &scanRequest, sizeof(scanRequest)); if (NULL != wrqu->data.pointer) { /* set scanType, active or passive */ if ((IW_SCAN_TYPE_ACTIVE == scanReq->scan_type) || (eSIR_ACTIVE_SCAN == pHddCtx->scan_info.scan_mode)) { scanRequest.scanType = eSIR_ACTIVE_SCAN; } else { scanRequest.scanType = eSIR_PASSIVE_SCAN; } /* set bssid using sockaddr from iw_scan_req */ vos_mem_copy(scanRequest.bssid, &scanReq->bssid.sa_data, sizeof(scanRequest.bssid) ); if (wrqu->data.flags & IW_SCAN_THIS_ESSID) { if(scanReq->essid_len && (scanReq->essid_len <= SIR_MAC_MAX_SSID_LENGTH)) { scanRequest.SSIDs.numOfSSIDs = 1; scanRequest.SSIDs.SSIDList =( tCsrSSIDInfo *)vos_mem_malloc(sizeof(tCsrSSIDInfo)); if(scanRequest.SSIDs.SSIDList) { scanRequest.SSIDs.SSIDList->SSID.length = scanReq->essid_len; vos_mem_copy(scanRequest.SSIDs.SSIDList-> SSID.ssId,scanReq->essid,scanReq->essid_len); } else { scanRequest.SSIDs.numOfSSIDs = 0; VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: Unable to allocate memory",__func__); VOS_ASSERT(0); } } else { hddLog(LOGE, FL("Invalid essid length : %d"), scanReq->essid_len); } } /* set min and max channel time */ scanRequest.minChnTime = scanReq->min_channel_time; scanRequest.maxChnTime = scanReq->max_channel_time; } else { if(pHddCtx->scan_info.scan_mode == eSIR_ACTIVE_SCAN) { /* set the scan type to active */ scanRequest.scanType = eSIR_ACTIVE_SCAN; } else { scanRequest.scanType = eSIR_PASSIVE_SCAN; } vos_mem_set( scanRequest.bssid, sizeof( tCsrBssid ), 0xff ); /* set min and max channel time to zero */ scanRequest.minChnTime = 0; scanRequest.maxChnTime = 0; } /* set BSSType to default type */ scanRequest.BSSType = eCSR_BSS_TYPE_ANY; /*Scan all the channels */ scanRequest.ChannelInfo.numOfChannels = 0; scanRequest.ChannelInfo.ChannelList = NULL; /* set requestType to full scan */ scanRequest.requestType = eCSR_SCAN_REQUEST_FULL_SCAN; /* if previous genIE is not NULL, update ScanIE */ if (0 != pwextBuf->genIE.length) { memset( &pHddCtx->scan_info.scanAddIE, 0, sizeof(pHddCtx->scan_info.scanAddIE) ); memcpy( pHddCtx->scan_info.scanAddIE.addIEdata, pwextBuf->genIE.addIEdata, pwextBuf->genIE.length ); pHddCtx->scan_info.scanAddIE.length = pwextBuf->genIE.length; /* Maximum length of each IE is SIR_MAC_MAX_IE_LENGTH */ if (SIR_MAC_MAX_IE_LENGTH >= pwextBuf->genIE.length) { memcpy( pwextBuf->roamProfile.addIEScan, pHddCtx->scan_info.scanAddIE.addIEdata, pHddCtx->scan_info.scanAddIE.length); pwextBuf->roamProfile.nAddIEScanLength = pHddCtx->scan_info.scanAddIE.length; } else { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "Invalid ScanIE, Length is %d", pwextBuf->genIE.length); } /* clear previous genIE after use it */ memset( &pwextBuf->genIE, 0, sizeof(pwextBuf->genIE) ); } /* push addIEScan in scanRequset if exist */ if (pHddCtx->scan_info.scanAddIE.addIEdata && pHddCtx->scan_info.scanAddIE.length) { scanRequest.uIEFieldLen = pHddCtx->scan_info.scanAddIE.length; scanRequest.pIEField = pHddCtx->scan_info.scanAddIE.addIEdata; } if (pHddCtx->spoofMacAddr.isEnabled && pHddCtx->cfg_ini->enableMacSpoofing == 1) { hddLog(LOG1, FL("MAC Spoofing enabled for current scan")); /* * Updating SelfSta Mac Addr in TL which will be used to get * staidx to fill TxBds for probe request during current scan */ status = WLANTL_updateSpoofMacAddr(pHddCtx->pvosContext, &pHddCtx->spoofMacAddr.randomMacAddr, &pAdapter->macAddressCurrent); if (status != eHAL_STATUS_SUCCESS) { hddLog(LOGE, FL("Failed to update MAC Spoof Addr in TL")); goto error; } } status = sme_ScanRequest( (WLAN_HDD_GET_CTX(pAdapter))->hHal, pAdapter->sessionId,&scanRequest, &scanId, &hdd_ScanRequestCallback, dev ); if (!HAL_STATUS_SUCCESS(status)) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s:sme_ScanRequest fail %d!!!",__func__, status); goto error; } pHddCtx->scan_info.mScanPending = TRUE; pHddCtx->scan_info.sessionId = pAdapter->sessionId; pHddCtx->scan_info.scanId = scanId; error: if ((wrqu->data.flags & IW_SCAN_THIS_ESSID) && (scanReq->essid_len)) vos_mem_free(scanRequest.SSIDs.SSIDList); EXIT(); return status; } int iw_set_scan(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { int ret; vos_ssr_protect(__func__); ret = __iw_set_scan(dev, info, wrqu, extra); vos_ssr_unprotect(__func__); return ret; } /**--------------------------------------------------------------------------- \brief __iw_get_scan() - This function returns the scan results to the wpa_supplicant \param - dev - Pointer to the net device. - info - Pointer to the iw_request_info. - wrqu - Pointer to the iwreq_data. - extra - Pointer to the data. \return - 0 for success, non zero for failure --------------------------------------------------------------------------*/ int __iw_get_scan(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { hdd_adapter_t *pAdapter; hdd_context_t *pHddCtx; tHalHandle hHal; tCsrScanResultInfo *pScanResult; eHalStatus status = eHAL_STATUS_SUCCESS; hdd_scan_info_t scanInfo; tScanResultHandle pResult; int i = 0, ret = 0; ENTER(); VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: enter buffer length %d!!!", __func__, (wrqu->data.length)?wrqu->data.length:IW_SCAN_MAX_DATA); pAdapter = WLAN_HDD_GET_PRIV_PTR(dev); if (NULL == pAdapter) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: Adapter is NULL",__func__); return -EINVAL; } pHddCtx = WLAN_HDD_GET_CTX(pAdapter); ret = wlan_hdd_validate_context(pHddCtx); if (0 != ret) { return ret; } hHal = WLAN_HDD_GET_HAL_CTX(pAdapter); if (NULL == hHal) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: Hal Context is NULL",__func__); return -EINVAL; } if (TRUE == pHddCtx->scan_info.mScanPending) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s:mScanPending is TRUE !!!",__func__); return -EAGAIN; } scanInfo.dev = dev; scanInfo.start = extra; scanInfo.info = info; if (0 == wrqu->data.length) { scanInfo.end = extra + IW_SCAN_MAX_DATA; } else { scanInfo.end = extra + wrqu->data.length; } status = sme_ScanGetResult(hHal,pAdapter->sessionId,NULL,&pResult); if (NULL == pResult) { // no scan results hddLog(LOG1,"__iw_get_scan: NULL Scan Result "); return 0; } pScanResult = sme_ScanResultGetFirst(hHal, pResult); while (pScanResult) { status = hdd_IndicateScanResult(&scanInfo, pScanResult); if (0 != status) { break; } i++; pScanResult = sme_ScanResultGetNext(hHal, pResult); } sme_ScanResultPurge(hHal, pResult); VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: exit total %d BSS reported !!!",__func__, i); EXIT(); return status; } int iw_get_scan(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { int ret; vos_ssr_protect(__func__); ret = __iw_get_scan(dev, info, wrqu, extra); vos_ssr_unprotect(__func__); return ret; } #if 0 static eHalStatus hdd_CscanRequestCallback(tHalHandle halHandle, void *pContext, tANI_U32 scanId, eCsrScanStatus status) { struct net_device *dev = (struct net_device *) pContext; hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev) ; hdd_wext_state_t *pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter); union iwreq_data wrqu; int we_event; char *msg; VOS_STATUS vos_status = VOS_STATUS_SUCCESS; ENTER(); hddLog(LOG1,"%s called with halHandle = %pK, pContext = %pK, scanID = %d," " returned status = %d", __func__, halHandle, pContext, (int) scanId, (int) status); /* Check the scanId */ if (pwextBuf->scanId != scanId) { hddLog(LOGW, "%s called with mismatched scanId pWextState->scanId = %d " "scanId = %d ", __func__, (int) pwextBuf->scanId, (int) scanId); } /* Scan is no longer pending */ pwextBuf->mScanPending = VOS_FALSE; // notify any applications that may be interested memset(&wrqu, '\0', sizeof(wrqu)); we_event = SIOCGIWSCAN; msg = NULL; wireless_send_event(dev, we_event, &wrqu, msg); vos_status = vos_event_set(&pwextBuf->vosevent); if (!VOS_IS_STATUS_SUCCESS(vos_status)) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, ("ERROR: HDD vos_event_set failed!!")); return VOS_STATUS_E_FAILURE; } EXIT(); VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: exit !!!",__func__); return eHAL_STATUS_SUCCESS; } #endif int iw_set_cscan(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev) ; hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter); hdd_wext_state_t *pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter); tCsrScanRequest scanRequest; v_U32_t scanId = 0; eHalStatus status = eHAL_STATUS_SUCCESS; v_U8_t channelIdx; ENTER(); VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: enter !!!",__func__); #ifdef WLAN_BTAMP_FEATURE //Scan not supported when AMP traffic is on. if( VOS_TRUE == WLANBAP_AmpSessionOn() ) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: No scanning when AMP is on",__func__); return eHAL_STATUS_SUCCESS; } #endif if ((WLAN_HDD_GET_CTX(pAdapter))->isLogpInProgress) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s:LOGP in Progress. Ignore!!!",__func__); return eHAL_STATUS_SUCCESS; } vos_mem_zero( &scanRequest, sizeof(scanRequest)); if (NULL != wrqu->data.pointer) { char *str_ptr = NULL; tCsrSSIDInfo *SsidInfo = NULL; int num_ssid = 0; int i, j, ssid_start; hdd_scan_pending_option_e scanPendingOption = WEXT_SCAN_PENDING_GIVEUP; str_ptr = extra; i = WEXT_CSCAN_HEADER_SIZE; if( WEXT_CSCAN_PENDING_SECTION == str_ptr[i] ) { scanPendingOption = (hdd_scan_pending_option_e)str_ptr[++i]; ++i; } pHddCtx->scan_info.scan_pending_option = scanPendingOption; if(pHddCtx->scan_info.mScanPending == TRUE) { hddLog(LOG1,"%s: mScanPending is TRUE",__func__); /* If any scan is pending, just giveup this scan request */ if(WEXT_SCAN_PENDING_GIVEUP == scanPendingOption) { pHddCtx->scan_info.waitScanResult = FALSE; return eHAL_STATUS_SUCCESS; } /* If any scan pending, wait till finish current scan, and try this scan request when previous scan finish */ else if(WEXT_SCAN_PENDING_DELAY == scanPendingOption) { pHddCtx->scan_info.waitScanResult = TRUE; vos_event_reset(&pHddCtx->scan_info.scan_finished_event); if(vos_wait_single_event(&pHddCtx->scan_info.scan_finished_event, WEXT_CSCAN_SCAN_DONE_WAIT_TIME)) { hddLog(LOG1,"%s: Previous SCAN does not finished on time",__func__); return eHAL_STATUS_SUCCESS; } } /* Piggyback previous scan result */ else if(WEXT_SCAN_PENDING_PIGGYBACK == scanPendingOption) { pHddCtx->scan_info.waitScanResult = TRUE; return eHAL_STATUS_SUCCESS; } } pHddCtx->scan_info.waitScanResult = FALSE; /* Check for scan IE */ while( WEXT_CSCAN_SSID_SECTION == str_ptr[i] ) { /* ssid_len */ if(str_ptr[++i] != WEXT_CSCAN_CHANNEL_SECTION) { /* total number of ssid's */ num_ssid++; /* increment length filed */ i += str_ptr[i] + 1; } /* i should be saved and it will be pointing to 'C' */ } VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: numSsid %d !!!",__func__, num_ssid); if( num_ssid ) { /* To be fixed in SME and PE: override the number of ssid with 1, * as SME and PE does not handle multiple SSID in scan request * */ scanRequest.SSIDs.numOfSSIDs = num_ssid; /* Allocate num_ssid tCsrSSIDInfo structure */ SsidInfo = scanRequest.SSIDs.SSIDList =( tCsrSSIDInfo *)vos_mem_malloc(num_ssid*sizeof(tCsrSSIDInfo)); if(NULL == scanRequest.SSIDs.SSIDList) { hddLog(VOS_TRACE_LEVEL_ERROR, "memory alloc failed SSIDInfo buffer"); return -ENOMEM; } /* copy all the ssid's and their length */ ssid_start = WEXT_CSCAN_HEADER_SIZE + 1;/* skipping 'S' */ for(j = 0; j < num_ssid; j++) { if( SIR_MAC_MAX_SSID_LENGTH < str_ptr[ssid_start]){ scanRequest.SSIDs.numOfSSIDs -= 1; } else{ /* get the ssid length */ SsidInfo->SSID.length = str_ptr[ssid_start++]; vos_mem_copy(SsidInfo->SSID.ssId, &str_ptr[ssid_start], SsidInfo->SSID.length); hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "SSID number %d: %s", j, SsidInfo->SSID.ssId); } /* skipping length */ ssid_start += str_ptr[ssid_start - 1] + 1; /* Store next ssid info */ SsidInfo++; } } /* Check for Channel IE */ if ( WEXT_CSCAN_CHANNEL_SECTION == str_ptr[i]) { if( str_ptr[++i] == 0 ) { scanRequest.ChannelInfo.numOfChannels = 0; scanRequest.ChannelInfo.ChannelList = NULL; i++; } else { /* increment the counter */ scanRequest.ChannelInfo.numOfChannels = str_ptr[i++]; /* store temp channel list */ /* SME expects 1 byte channel content */ scanRequest.ChannelInfo.ChannelList = vos_mem_malloc(scanRequest.ChannelInfo.numOfChannels * sizeof(v_U8_t)); if(NULL == scanRequest.ChannelInfo.ChannelList) { hddLog(LOGE, "memory alloc failed for channel list creation"); status = -ENOMEM; goto exit_point; } for(channelIdx = 0; channelIdx < scanRequest.ChannelInfo.numOfChannels; channelIdx++) { /* SCAN request from upper layer has 2 bytes channel */ scanRequest.ChannelInfo.ChannelList[channelIdx] = (v_U8_t)str_ptr[i]; i += sizeof(v_U16_t); } } } /* Set default */ scanRequest.scanType = eSIR_ACTIVE_SCAN; scanRequest.minChnTime = 0; scanRequest.maxChnTime = 0; /* Now i is pointing to passive dwell dwell time */ /* 'P',min dwell time, max dwell time */ /* next two offsets contain min and max channel time */ if( WEXT_CSCAN_PASV_DWELL_SECTION == (str_ptr[i]) ) { /* No SSID specified, num_ssid == 0, then start paasive scan */ if (!num_ssid || (eSIR_PASSIVE_SCAN == pHddCtx->scan_info.scan_mode)) { scanRequest.scanType = eSIR_PASSIVE_SCAN; scanRequest.minChnTime = (v_U8_t)str_ptr[++i];//scanReq->min_channel_time; scanRequest.maxChnTime = (v_U8_t)str_ptr[++i];//scanReq->max_channel_time; i++; } else { i += 3; } } /* H indicates active channel time */ if( WEXT_CSCAN_HOME_DWELL_SECTION == (str_ptr[i]) ) { if (num_ssid || (eSIR_ACTIVE_SCAN == pHddCtx->scan_info.scan_mode)) { scanRequest.scanType = eSIR_ACTIVE_SCAN; scanRequest.minChnTime = str_ptr[++i];//scanReq->min_channel_time; scanRequest.maxChnTime = str_ptr[++i];//scanReq->max_channel_time; i++; } else { i +=3; } } scanRequest.BSSType = eCSR_BSS_TYPE_ANY; /* set requestType to full scan */ scanRequest.requestType = eCSR_SCAN_REQUEST_FULL_SCAN; pHddCtx->scan_info.mScanPending = TRUE; /* if previous genIE is not NULL, update ScanIE */ if(0 != pwextBuf->genIE.length) { memset( &pHddCtx->scan_info.scanAddIE, 0, sizeof(pHddCtx->scan_info.scanAddIE) ); memcpy( pHddCtx->scan_info.scanAddIE.addIEdata, pwextBuf->genIE.addIEdata, pwextBuf->genIE.length ); pHddCtx->scan_info.scanAddIE.length = pwextBuf->genIE.length; if (SIR_MAC_MAX_IE_LENGTH >= pwextBuf->genIE.length) { memcpy( pwextBuf->roamProfile.addIEScan, pHddCtx->scan_info.scanAddIE.addIEdata, pHddCtx->scan_info.scanAddIE.length); pwextBuf->roamProfile.nAddIEScanLength = pHddCtx->scan_info.scanAddIE.length; } else { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "Invalid ScanIE, Length is %d", pwextBuf->genIE.length); } /* clear previous genIE after use it */ memset( &pwextBuf->genIE, 0, sizeof(pwextBuf->genIE) ); } /* push addIEScan in scanRequset if exist */ if (pHddCtx->scan_info.scanAddIE.addIEdata && pHddCtx->scan_info.scanAddIE.length) { scanRequest.uIEFieldLen = pHddCtx->scan_info.scanAddIE.length; scanRequest.pIEField = pHddCtx->scan_info.scanAddIE.addIEdata; } status = sme_ScanRequest( (WLAN_HDD_GET_CTX(pAdapter))->hHal, pAdapter->sessionId,&scanRequest, &scanId, &hdd_ScanRequestCallback, dev ); if( !HAL_STATUS_SUCCESS(status) ) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s: SME scan fail status %d !!!",__func__, status); pHddCtx->scan_info.mScanPending = FALSE; status = -EINVAL; goto exit_point; } pHddCtx->scan_info.scanId = scanId; pHddCtx->scan_info.sessionId = pAdapter->sessionId; } //end of data->pointer else { status = -1; } exit_point: /* free ssidlist */ if (scanRequest.SSIDs.SSIDList) { vos_mem_free(scanRequest.SSIDs.SSIDList); } /* free the channel list */ if(scanRequest.ChannelInfo.ChannelList) { vos_mem_free((void*)scanRequest.ChannelInfo.ChannelList); } EXIT(); VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: exit !!!",__func__); return status; } /* Abort any MAC scan if in progress */ tSirAbortScanStatus hdd_abort_mac_scan(hdd_context_t* pHddCtx, tANI_U8 sessionId, eCsrAbortReason reason) { return sme_AbortMacScan(pHddCtx->hHal, sessionId, reason); }