530 lines
19 KiB
C++
530 lines
19 KiB
C++
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "android/net/wifi/nl80211/IWifiScannerImpl.h"
|
|
#include "wificond/scanning/scan_utils.h"
|
|
|
|
#include <array>
|
|
#include <vector>
|
|
|
|
#include <linux/netlink.h>
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <android-base/logging.h>
|
|
|
|
#include "wificond/net/kernel-header-latest/nl80211.h"
|
|
#include "wificond/net/netlink_manager.h"
|
|
#include "wificond/net/nl80211_packet.h"
|
|
#include "wificond/scanning/scan_result.h"
|
|
|
|
using android::net::wifi::nl80211::IWifiScannerImpl;
|
|
using android::net::wifi::nl80211::NativeScanResult;
|
|
using android::net::wifi::nl80211::RadioChainInfo;
|
|
using std::array;
|
|
using std::unique_ptr;
|
|
using std::vector;
|
|
|
|
namespace android {
|
|
namespace wificond {
|
|
namespace {
|
|
|
|
constexpr uint8_t kElemIdSsid = 0;
|
|
constexpr unsigned int kMsecPerSec = 1000;
|
|
|
|
} // namespace
|
|
|
|
ScanUtils::ScanUtils(NetlinkManager* netlink_manager)
|
|
: netlink_manager_(netlink_manager) {
|
|
if (!netlink_manager_->IsStarted()) {
|
|
netlink_manager_->Start();
|
|
}
|
|
}
|
|
|
|
ScanUtils::~ScanUtils() {}
|
|
|
|
void ScanUtils::SubscribeScanResultNotification(
|
|
uint32_t interface_index,
|
|
OnScanResultsReadyHandler handler) {
|
|
netlink_manager_->SubscribeScanResultNotification(interface_index, handler);
|
|
}
|
|
|
|
void ScanUtils::UnsubscribeScanResultNotification(uint32_t interface_index) {
|
|
netlink_manager_->UnsubscribeScanResultNotification(interface_index);
|
|
}
|
|
|
|
void ScanUtils::SubscribeSchedScanResultNotification(
|
|
uint32_t interface_index,
|
|
OnSchedScanResultsReadyHandler handler) {
|
|
netlink_manager_->SubscribeSchedScanResultNotification(interface_index,
|
|
handler);
|
|
}
|
|
|
|
void ScanUtils::UnsubscribeSchedScanResultNotification(
|
|
uint32_t interface_index) {
|
|
netlink_manager_->UnsubscribeSchedScanResultNotification(interface_index);
|
|
}
|
|
|
|
bool ScanUtils::GetScanResult(uint32_t interface_index,
|
|
vector<NativeScanResult>* out_scan_results) {
|
|
NL80211Packet get_scan(
|
|
netlink_manager_->GetFamilyId(),
|
|
NL80211_CMD_GET_SCAN,
|
|
netlink_manager_->GetSequenceNumber(),
|
|
getpid());
|
|
get_scan.AddFlag(NLM_F_DUMP);
|
|
NL80211Attr<uint32_t> ifindex(NL80211_ATTR_IFINDEX, interface_index);
|
|
get_scan.AddAttribute(ifindex);
|
|
|
|
vector<unique_ptr<const NL80211Packet>> response;
|
|
if (!netlink_manager_->SendMessageAndGetResponses(get_scan, &response)) {
|
|
LOG(ERROR) << "NL80211_CMD_GET_SCAN dump failed";
|
|
return false;
|
|
}
|
|
if (response.empty()) {
|
|
LOG(INFO) << "Unexpected empty scan result!";
|
|
return true;
|
|
}
|
|
|
|
for (auto& packet : response) {
|
|
if (packet->GetMessageType() == NLMSG_ERROR) {
|
|
LOG(ERROR) << "Receive ERROR message: "
|
|
<< strerror(packet->GetErrorCode());
|
|
continue;
|
|
}
|
|
if (packet->GetMessageType() != netlink_manager_->GetFamilyId()) {
|
|
LOG(ERROR) << "Wrong message type: "
|
|
<< packet->GetMessageType();
|
|
continue;
|
|
}
|
|
uint32_t if_index;
|
|
if (!packet->GetAttributeValue(NL80211_ATTR_IFINDEX, &if_index)) {
|
|
LOG(ERROR) << "No interface index in scan result.";
|
|
continue;
|
|
}
|
|
if (if_index != interface_index) {
|
|
LOG(WARNING) << "Uninteresting scan result for interface: " << if_index;
|
|
continue;
|
|
}
|
|
|
|
NativeScanResult scan_result;
|
|
if (!ParseScanResult(std::move(packet), &scan_result)) {
|
|
LOG(DEBUG) << "Ignore invalid scan result";
|
|
continue;
|
|
}
|
|
out_scan_results->push_back(std::move(scan_result));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ScanUtils::ParseScanResult(unique_ptr<const NL80211Packet> packet,
|
|
NativeScanResult* scan_result) {
|
|
if (packet->GetCommand() != NL80211_CMD_NEW_SCAN_RESULTS) {
|
|
LOG(ERROR) << "Wrong command for new scan result message";
|
|
return false;
|
|
}
|
|
NL80211NestedAttr bss(0);
|
|
if (packet->GetAttribute(NL80211_ATTR_BSS, &bss)) {
|
|
array<uint8_t, ETH_ALEN> bssid;
|
|
if (!bss.GetAttributeValue(NL80211_BSS_BSSID, &bssid)) {
|
|
LOG(ERROR) << "Failed to get BSSID from scan result packet";
|
|
return false;
|
|
}
|
|
uint32_t freq;
|
|
if (!bss.GetAttributeValue(NL80211_BSS_FREQUENCY, &freq)) {
|
|
LOG(ERROR) << "Failed to get Frequency from scan result packet";
|
|
return false;
|
|
}
|
|
vector<uint8_t> ie;
|
|
if (!bss.GetAttributeValue(NL80211_BSS_INFORMATION_ELEMENTS, &ie)) {
|
|
LOG(ERROR) << "Failed to get Information Element from scan result packet";
|
|
return false;
|
|
}
|
|
vector<uint8_t> ssid;
|
|
if (!GetSSIDFromInfoElement(ie, &ssid)) {
|
|
// Skip BSS without SSID IE.
|
|
// These scan results are considered as malformed.
|
|
return false;
|
|
}
|
|
uint64_t last_seen_since_boot_microseconds;
|
|
if (!GetBssTimestamp(bss, &last_seen_since_boot_microseconds)) {
|
|
// Logging is done inside |GetBssTimestamp|.
|
|
return false;
|
|
}
|
|
int32_t signal;
|
|
if (!bss.GetAttributeValue(NL80211_BSS_SIGNAL_MBM, &signal)) {
|
|
LOG(ERROR) << "Failed to get Signal Strength from scan result packet";
|
|
return false;
|
|
}
|
|
uint16_t capability;
|
|
if (!bss.GetAttributeValue(NL80211_BSS_CAPABILITY, &capability)) {
|
|
LOG(ERROR) << "Failed to get capability field from scan result packet";
|
|
return false;
|
|
}
|
|
bool associated = false;
|
|
uint32_t bss_status;
|
|
if (bss.GetAttributeValue(NL80211_BSS_STATUS, &bss_status) &&
|
|
(bss_status == NL80211_BSS_STATUS_AUTHENTICATED ||
|
|
bss_status == NL80211_BSS_STATUS_ASSOCIATED)) {
|
|
associated = true;
|
|
}
|
|
std::vector<RadioChainInfo> radio_chain_infos;
|
|
ParseRadioChainInfos(bss, &radio_chain_infos);
|
|
|
|
*scan_result =
|
|
NativeScanResult(ssid, bssid, ie, freq, signal,
|
|
last_seen_since_boot_microseconds,
|
|
capability, associated, radio_chain_infos);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ScanUtils::GetBssTimestampForTesting(
|
|
const NL80211NestedAttr& bss,
|
|
uint64_t* last_seen_since_boot_microseconds){
|
|
return GetBssTimestamp(bss, last_seen_since_boot_microseconds);
|
|
}
|
|
|
|
bool ScanUtils::GetBssTimestamp(const NL80211NestedAttr& bss,
|
|
uint64_t* last_seen_since_boot_microseconds){
|
|
uint64_t last_seen_since_boot_nanoseconds;
|
|
if (bss.GetAttributeValue(NL80211_BSS_LAST_SEEN_BOOTTIME,
|
|
&last_seen_since_boot_nanoseconds)) {
|
|
*last_seen_since_boot_microseconds = last_seen_since_boot_nanoseconds / 1000;
|
|
} else {
|
|
// Fall back to use TSF if we can't find NL80211_BSS_LAST_SEEN_BOOTTIME
|
|
// attribute.
|
|
if (!bss.GetAttributeValue(NL80211_BSS_TSF, last_seen_since_boot_microseconds)) {
|
|
LOG(ERROR) << "Failed to get TSF from scan result packet";
|
|
return false;
|
|
}
|
|
uint64_t beacon_tsf_microseconds;
|
|
if (bss.GetAttributeValue(NL80211_BSS_BEACON_TSF, &beacon_tsf_microseconds)) {
|
|
*last_seen_since_boot_microseconds = std::max(*last_seen_since_boot_microseconds,
|
|
beacon_tsf_microseconds);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ScanUtils::ParseRadioChainInfos(
|
|
const NL80211NestedAttr& bss,
|
|
std::vector<RadioChainInfo> *radio_chain_infos) {
|
|
*radio_chain_infos = {};
|
|
// Contains a nested array of signal strength attributes: (ChainId, Rssi in dBm)
|
|
NL80211NestedAttr radio_chain_infos_attr(0);
|
|
if (!bss.GetAttribute(NL80211_BSS_CHAIN_SIGNAL, &radio_chain_infos_attr)) {
|
|
return false;
|
|
}
|
|
std::vector<NL80211Attr<int8_t>> radio_chain_infos_attrs;
|
|
if (!radio_chain_infos_attr.GetListOfAttributes(
|
|
&radio_chain_infos_attrs)) {
|
|
LOG(ERROR) << "Failed to get radio chain info attrs within "
|
|
<< "NL80211_BSS_CHAIN_SIGNAL";
|
|
return false;
|
|
}
|
|
for (const auto& attr : radio_chain_infos_attrs) {
|
|
RadioChainInfo radio_chain_info;
|
|
radio_chain_info.chain_id = attr.GetAttributeId();
|
|
radio_chain_info.level = attr.GetValue();
|
|
radio_chain_infos->push_back(radio_chain_info);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ScanUtils::GetSSIDFromInfoElement(const vector<uint8_t>& ie,
|
|
vector<uint8_t>* ssid) {
|
|
// Information elements are stored in 'TLV' format.
|
|
// Field: | Type | Length | Value |
|
|
// Length: | 1 | 1 | variable |
|
|
// Content:| Element ID | Length of the Value field | Element payload |
|
|
const uint8_t* end = ie.data() + ie.size();
|
|
const uint8_t* ptr = ie.data();
|
|
// +1 means we must have space for the length field.
|
|
while (ptr + 1 < end) {
|
|
uint8_t type = *ptr;
|
|
uint8_t length = *(ptr + 1);
|
|
// Length field is invalid.
|
|
if (ptr + 1 + length >= end) {
|
|
return false;
|
|
}
|
|
// SSID element is found.
|
|
if (type == kElemIdSsid) {
|
|
// SSID is an empty string.
|
|
if (length == 0) {
|
|
*ssid = vector<uint8_t>();
|
|
} else {
|
|
*ssid = vector<uint8_t>(ptr + 2, ptr + length + 2);
|
|
}
|
|
return true;
|
|
}
|
|
ptr += 2 + length;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ScanUtils::Scan(uint32_t interface_index,
|
|
bool request_random_mac,
|
|
int scan_type,
|
|
bool enable_6ghz_rnr,
|
|
const vector<vector<uint8_t>>& ssids,
|
|
const vector<uint32_t>& freqs,
|
|
int* error_code) {
|
|
NL80211Packet trigger_scan(
|
|
netlink_manager_->GetFamilyId(),
|
|
NL80211_CMD_TRIGGER_SCAN,
|
|
netlink_manager_->GetSequenceNumber(),
|
|
getpid());
|
|
// If we do not use NLM_F_ACK, we only receive a unicast repsonse
|
|
// when there is an error. If everything is good, scan results notification
|
|
// will only be sent through multicast.
|
|
// If NLM_F_ACK is set, there will always be an unicast repsonse, either an
|
|
// ERROR or an ACK message. The handler will always be called and removed by
|
|
// NetlinkManager.
|
|
trigger_scan.AddFlag(NLM_F_ACK);
|
|
NL80211Attr<uint32_t> if_index_attr(NL80211_ATTR_IFINDEX, interface_index);
|
|
|
|
NL80211NestedAttr ssids_attr(NL80211_ATTR_SCAN_SSIDS);
|
|
for (size_t i = 0; i < ssids.size(); i++) {
|
|
ssids_attr.AddAttribute(NL80211Attr<vector<uint8_t>>(i, ssids[i]));
|
|
}
|
|
NL80211NestedAttr freqs_attr(NL80211_ATTR_SCAN_FREQUENCIES);
|
|
for (size_t i = 0; i < freqs.size(); i++) {
|
|
freqs_attr.AddAttribute(NL80211Attr<uint32_t>(i, freqs[i]));
|
|
}
|
|
|
|
trigger_scan.AddAttribute(if_index_attr);
|
|
trigger_scan.AddAttribute(ssids_attr);
|
|
// An absence of NL80211_ATTR_SCAN_FREQUENCIES attribue informs kernel to
|
|
// scan all supported frequencies.
|
|
if (!freqs.empty()) {
|
|
trigger_scan.AddAttribute(freqs_attr);
|
|
}
|
|
|
|
uint32_t scan_flags = 0;
|
|
if (request_random_mac) {
|
|
scan_flags |= NL80211_SCAN_FLAG_RANDOM_ADDR;
|
|
}
|
|
switch (scan_type) {
|
|
case IWifiScannerImpl::SCAN_TYPE_LOW_SPAN:
|
|
scan_flags |= NL80211_SCAN_FLAG_LOW_SPAN;
|
|
break;
|
|
case IWifiScannerImpl::SCAN_TYPE_LOW_POWER:
|
|
scan_flags |= NL80211_SCAN_FLAG_LOW_POWER;
|
|
break;
|
|
case IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY:
|
|
scan_flags |= NL80211_SCAN_FLAG_HIGH_ACCURACY;
|
|
break;
|
|
case IWifiScannerImpl::SCAN_TYPE_DEFAULT:
|
|
break;
|
|
default:
|
|
CHECK(0) << "Invalid scan type received: " << scan_type;
|
|
}
|
|
if (enable_6ghz_rnr) {
|
|
scan_flags |= NL80211_SCAN_FLAG_COLOCATED_6GHZ;
|
|
}
|
|
if (scan_flags) {
|
|
trigger_scan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_ATTR_SCAN_FLAGS,
|
|
scan_flags));
|
|
LOG(DEBUG) << "Triggering scan with scan_flag=" << scan_flags;
|
|
}
|
|
// We are receiving an ERROR/ACK message instead of the actual
|
|
// scan results here, so it is OK to expect a timely response because
|
|
// kernel is supposed to send the ERROR/ACK back before the scan starts.
|
|
vector<unique_ptr<const NL80211Packet>> response;
|
|
if (!netlink_manager_->SendMessageAndGetAckOrError(trigger_scan,
|
|
error_code)) {
|
|
// Logging is done inside |SendMessageAndGetAckOrError|.
|
|
return false;
|
|
}
|
|
if (*error_code != 0) {
|
|
LOG(ERROR) << "NL80211_CMD_TRIGGER_SCAN failed: " << strerror(*error_code);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ScanUtils::StopScheduledScan(uint32_t interface_index) {
|
|
NL80211Packet stop_sched_scan(
|
|
netlink_manager_->GetFamilyId(),
|
|
NL80211_CMD_STOP_SCHED_SCAN,
|
|
netlink_manager_->GetSequenceNumber(),
|
|
getpid());
|
|
// Force an ACK response upon success.
|
|
stop_sched_scan.AddFlag(NLM_F_ACK);
|
|
stop_sched_scan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_ATTR_IFINDEX, interface_index));
|
|
vector<unique_ptr<const NL80211Packet>> response;
|
|
int error_code;
|
|
if (!netlink_manager_->SendMessageAndGetAckOrError(stop_sched_scan,
|
|
&error_code)) {
|
|
LOG(ERROR) << "NL80211_CMD_STOP_SCHED_SCAN failed";
|
|
return false;
|
|
}
|
|
if (error_code == ENOENT) {
|
|
LOG(WARNING) << "Scheduled scan is not running!";
|
|
return false;
|
|
} else if (error_code != 0) {
|
|
LOG(ERROR) << "Receive ERROR message in response to"
|
|
<< " 'stop scheduled scan' request: "
|
|
<< strerror(error_code);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ScanUtils::AbortScan(uint32_t interface_index) {
|
|
NL80211Packet abort_scan(
|
|
netlink_manager_->GetFamilyId(),
|
|
NL80211_CMD_ABORT_SCAN,
|
|
netlink_manager_->GetSequenceNumber(),
|
|
getpid());
|
|
|
|
// Force an ACK response upon success.
|
|
abort_scan.AddFlag(NLM_F_ACK);
|
|
abort_scan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_ATTR_IFINDEX, interface_index));
|
|
|
|
if (!netlink_manager_->SendMessageAndGetAck(abort_scan)) {
|
|
LOG(ERROR) << "NL80211_CMD_ABORT_SCAN failed";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ScanUtils::StartScheduledScan(
|
|
uint32_t interface_index,
|
|
const SchedScanIntervalSetting& interval_setting,
|
|
int32_t rssi_threshold_2g,
|
|
int32_t rssi_threshold_5g,
|
|
int32_t rssi_threshold_6g,
|
|
const SchedScanReqFlags& req_flags,
|
|
const std::vector<std::vector<uint8_t>>& scan_ssids,
|
|
const std::vector<std::vector<uint8_t>>& match_ssids,
|
|
const std::vector<uint32_t>& freqs,
|
|
int* error_code) {
|
|
NL80211Packet start_sched_scan(
|
|
netlink_manager_->GetFamilyId(),
|
|
NL80211_CMD_START_SCHED_SCAN,
|
|
netlink_manager_->GetSequenceNumber(),
|
|
getpid());
|
|
// Force an ACK response upon success.
|
|
start_sched_scan.AddFlag(NLM_F_ACK);
|
|
|
|
NL80211NestedAttr scan_ssids_attr(NL80211_ATTR_SCAN_SSIDS);
|
|
for (size_t i = 0; i < scan_ssids.size(); i++) {
|
|
scan_ssids_attr.AddAttribute(NL80211Attr<vector<uint8_t>>(i, scan_ssids[i]));
|
|
}
|
|
NL80211NestedAttr freqs_attr(NL80211_ATTR_SCAN_FREQUENCIES);
|
|
for (size_t i = 0; i < freqs.size(); i++) {
|
|
freqs_attr.AddAttribute(NL80211Attr<uint32_t>(i, freqs[i]));
|
|
}
|
|
|
|
// Structure of attributes of scheduled scan filters:
|
|
// | Nested Attribute: id: NL80211_ATTR_SCHED_SCAN_MATCH |
|
|
// | Nested Attributed: id: 0 | Nested Attributed: id: 1 | Nested Attr: id: 2 | ... |
|
|
// | MATCH_SSID | MATCH_RSSI(optional) | MATCH_SSID | MACTCH_RSSI(optional) | MATCH_RSSI(optinal, global) | ... |
|
|
NL80211NestedAttr scan_match_attr(NL80211_ATTR_SCHED_SCAN_MATCH);
|
|
for (size_t i = 0; i < match_ssids.size(); i++) {
|
|
NL80211NestedAttr match_group(i);
|
|
match_group.AddAttribute(
|
|
NL80211Attr<vector<uint8_t>>(NL80211_SCHED_SCAN_MATCH_ATTR_SSID, match_ssids[i]));
|
|
match_group.AddAttribute(
|
|
NL80211Attr<int32_t>(NL80211_SCHED_SCAN_MATCH_ATTR_RSSI, rssi_threshold_5g));
|
|
scan_match_attr.AddAttribute(match_group);
|
|
}
|
|
start_sched_scan.AddAttribute(scan_match_attr);
|
|
|
|
// We set 5g threshold for default and ajust threshold for 2g band.
|
|
// check sched_scan supported before set NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST attribute.
|
|
if (req_flags.request_sched_scan_relative_rssi) {
|
|
struct nl80211_bss_select_rssi_adjust rssi_adjust;
|
|
rssi_adjust.band = NL80211_BAND_2GHZ;
|
|
rssi_adjust.delta = static_cast<int8_t>(rssi_threshold_2g - rssi_threshold_5g);
|
|
NL80211Attr<vector<uint8_t>> rssi_adjust_attr(
|
|
NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
|
|
vector<uint8_t>(
|
|
reinterpret_cast<uint8_t*>(&rssi_adjust),
|
|
reinterpret_cast<uint8_t*>(&rssi_adjust) + sizeof(rssi_adjust)));
|
|
start_sched_scan.AddAttribute(rssi_adjust_attr);
|
|
}
|
|
|
|
//TODO: No adjustment is possible now for 6GHz due to lack of definition in
|
|
//nl80211.h for NL80211_BAND_6GHZ attribute
|
|
|
|
// Append all attributes to the NL80211_CMD_START_SCHED_SCAN packet.
|
|
start_sched_scan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_ATTR_IFINDEX, interface_index));
|
|
start_sched_scan.AddAttribute(scan_ssids_attr);
|
|
// An absence of NL80211_ATTR_SCAN_FREQUENCIES attribue informs kernel to
|
|
// scan all supported frequencies.
|
|
if (!freqs.empty()) {
|
|
start_sched_scan.AddAttribute(freqs_attr);
|
|
}
|
|
|
|
if (!interval_setting.plans.empty()) {
|
|
NL80211NestedAttr scan_plans(NL80211_ATTR_SCHED_SCAN_PLANS);
|
|
for (unsigned int i = 0; i < interval_setting.plans.size(); i++) {
|
|
NL80211NestedAttr scan_plan(i + 1);
|
|
scan_plan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_SCHED_SCAN_PLAN_INTERVAL,
|
|
interval_setting.plans[i].interval_ms / kMsecPerSec));
|
|
scan_plan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_SCHED_SCAN_PLAN_ITERATIONS,
|
|
interval_setting.plans[i].n_iterations));
|
|
scan_plans.AddAttribute(scan_plan);
|
|
}
|
|
NL80211NestedAttr last_scan_plan(interval_setting.plans.size() + 1);
|
|
last_scan_plan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_SCHED_SCAN_PLAN_INTERVAL,
|
|
interval_setting.final_interval_ms / kMsecPerSec));
|
|
scan_plans.AddAttribute(last_scan_plan);
|
|
start_sched_scan.AddAttribute(scan_plans);
|
|
} else {
|
|
start_sched_scan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_ATTR_SCHED_SCAN_INTERVAL,
|
|
interval_setting.final_interval_ms));
|
|
}
|
|
uint32_t scan_flags = 0;
|
|
if (req_flags.request_random_mac) {
|
|
scan_flags |= NL80211_SCAN_FLAG_RANDOM_ADDR;
|
|
}
|
|
if (req_flags.request_low_power) {
|
|
scan_flags |= NL80211_SCAN_FLAG_LOW_POWER;
|
|
}
|
|
if (scan_flags) {
|
|
start_sched_scan.AddAttribute(
|
|
NL80211Attr<uint32_t>(NL80211_ATTR_SCAN_FLAGS,
|
|
scan_flags));
|
|
}
|
|
|
|
vector<unique_ptr<const NL80211Packet>> response;
|
|
if (!netlink_manager_->SendMessageAndGetAckOrError(start_sched_scan,
|
|
error_code)) {
|
|
// Logging is done inside |SendMessageAndGetAckOrError|.
|
|
return false;
|
|
}
|
|
if (*error_code != 0) {
|
|
LOG(ERROR) << "NL80211_CMD_START_SCHED_SCAN failed: " << strerror(*error_code);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace wificond
|
|
} // namespace android
|