256 lines
8.6 KiB
C++
256 lines
8.6 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 "wificond/client_interface_impl.h"
|
|
|
|
#include <vector>
|
|
|
|
#include <android-base/logging.h>
|
|
#include <wifi_system/supplicant_manager.h>
|
|
|
|
#include "wificond/client_interface_binder.h"
|
|
#include "wificond/net/mlme_event.h"
|
|
#include "wificond/net/netlink_utils.h"
|
|
#include "wificond/scanning/offload/offload_service_utils.h"
|
|
#include "wificond/scanning/scan_result.h"
|
|
#include "wificond/scanning/scan_utils.h"
|
|
#include "wificond/scanning/scanner_impl.h"
|
|
|
|
using android::net::wifi::IClientInterface;
|
|
using com::android::server::wifi::wificond::NativeScanResult;
|
|
using android::sp;
|
|
using android::wifi_system::InterfaceTool;
|
|
using android::wifi_system::SupplicantManager;
|
|
|
|
using std::endl;
|
|
using std::string;
|
|
using std::unique_ptr;
|
|
using std::vector;
|
|
|
|
namespace android {
|
|
namespace wificond {
|
|
|
|
MlmeEventHandlerImpl::MlmeEventHandlerImpl(ClientInterfaceImpl* client_interface)
|
|
: client_interface_(client_interface) {
|
|
}
|
|
|
|
MlmeEventHandlerImpl::~MlmeEventHandlerImpl() {
|
|
}
|
|
|
|
void MlmeEventHandlerImpl::OnConnect(unique_ptr<MlmeConnectEvent> event) {
|
|
if (!event->IsTimeout() && event->GetStatusCode() == 0) {
|
|
client_interface_->is_associated_ = true;
|
|
client_interface_->RefreshAssociateFreq();
|
|
client_interface_->bssid_ = event->GetBSSID();
|
|
} else {
|
|
if (event->IsTimeout()) {
|
|
LOG(INFO) << "Connect timeout";
|
|
}
|
|
client_interface_->is_associated_ = false;
|
|
client_interface_->bssid_.clear();
|
|
}
|
|
}
|
|
|
|
void MlmeEventHandlerImpl::OnRoam(unique_ptr<MlmeRoamEvent> event) {
|
|
if (event->GetStatusCode() == 0) {
|
|
client_interface_->is_associated_ = true;
|
|
client_interface_->RefreshAssociateFreq();
|
|
client_interface_->bssid_ = event->GetBSSID();
|
|
} else {
|
|
client_interface_->is_associated_ = false;
|
|
client_interface_->bssid_.clear();
|
|
}
|
|
}
|
|
|
|
void MlmeEventHandlerImpl::OnAssociate(unique_ptr<MlmeAssociateEvent> event) {
|
|
if (!event->IsTimeout() && event->GetStatusCode() == 0) {
|
|
client_interface_->is_associated_ = true;
|
|
client_interface_->RefreshAssociateFreq();
|
|
client_interface_->bssid_ = event->GetBSSID();
|
|
} else {
|
|
if (event->IsTimeout()) {
|
|
LOG(INFO) << "Associate timeout";
|
|
}
|
|
client_interface_->is_associated_ = false;
|
|
client_interface_->bssid_.clear();
|
|
}
|
|
}
|
|
|
|
void MlmeEventHandlerImpl::OnDisconnect(unique_ptr<MlmeDisconnectEvent> event) {
|
|
client_interface_->is_associated_ = false;
|
|
client_interface_->bssid_.clear();
|
|
}
|
|
|
|
void MlmeEventHandlerImpl::OnDisassociate(unique_ptr<MlmeDisassociateEvent> event) {
|
|
client_interface_->is_associated_ = false;
|
|
client_interface_->bssid_.clear();
|
|
}
|
|
|
|
|
|
ClientInterfaceImpl::ClientInterfaceImpl(
|
|
uint32_t wiphy_index,
|
|
const std::string& interface_name,
|
|
uint32_t interface_index,
|
|
const std::vector<uint8_t>& interface_mac_addr,
|
|
InterfaceTool* if_tool,
|
|
SupplicantManager* supplicant_manager,
|
|
NetlinkUtils* netlink_utils,
|
|
ScanUtils* scan_utils)
|
|
: wiphy_index_(wiphy_index),
|
|
interface_name_(interface_name),
|
|
interface_index_(interface_index),
|
|
interface_mac_addr_(interface_mac_addr),
|
|
if_tool_(if_tool),
|
|
supplicant_manager_(supplicant_manager),
|
|
netlink_utils_(netlink_utils),
|
|
scan_utils_(scan_utils),
|
|
offload_service_utils_(new OffloadServiceUtils()),
|
|
mlme_event_handler_(new MlmeEventHandlerImpl(this)),
|
|
binder_(new ClientInterfaceBinder(this)),
|
|
is_associated_(false) {
|
|
netlink_utils_->SubscribeMlmeEvent(
|
|
interface_index_,
|
|
mlme_event_handler_.get());
|
|
if (!netlink_utils_->GetWiphyInfo(wiphy_index_,
|
|
&band_info_,
|
|
&scan_capabilities_,
|
|
&wiphy_features_)) {
|
|
LOG(ERROR) << "Failed to get wiphy info from kernel";
|
|
}
|
|
LOG(INFO) << "create scanner for interface with index: "
|
|
<< (int)interface_index_;
|
|
scanner_ = new ScannerImpl(wiphy_index,
|
|
interface_index_,
|
|
scan_capabilities_,
|
|
wiphy_features_,
|
|
this,
|
|
netlink_utils_,
|
|
scan_utils_,
|
|
offload_service_utils_);
|
|
}
|
|
|
|
ClientInterfaceImpl::~ClientInterfaceImpl() {
|
|
binder_->NotifyImplDead();
|
|
scanner_->Invalidate();
|
|
DisableSupplicant();
|
|
netlink_utils_->UnsubscribeMlmeEvent(interface_index_);
|
|
if_tool_->SetUpState(interface_name_.c_str(), false);
|
|
}
|
|
|
|
sp<android::net::wifi::IClientInterface> ClientInterfaceImpl::GetBinder() const {
|
|
return binder_;
|
|
}
|
|
|
|
void ClientInterfaceImpl::Dump(std::stringstream* ss) const {
|
|
*ss << "------- Dump of client interface with index: "
|
|
<< interface_index_ << " and name: " << interface_name_
|
|
<< "-------" << endl;
|
|
*ss << "Max number of ssids for single shot scan: "
|
|
<< static_cast<int>(scan_capabilities_.max_num_scan_ssids) << endl;
|
|
*ss << "Max number of ssids for scheduled scan: "
|
|
<< static_cast<int>(scan_capabilities_.max_num_sched_scan_ssids) << endl;
|
|
*ss << "Max number of match sets for scheduled scan: "
|
|
<< static_cast<int>(scan_capabilities_.max_match_sets) << endl;
|
|
*ss << "Maximum number of scan plans: "
|
|
<< scan_capabilities_.max_num_scan_plans << endl;
|
|
*ss << "Max scan plan interval in seconds: "
|
|
<< scan_capabilities_.max_scan_plan_interval << endl;
|
|
*ss << "Max scan plan iterations: "
|
|
<< scan_capabilities_.max_scan_plan_iterations << endl;
|
|
*ss << "Device supports random MAC for single shot scan: "
|
|
<< wiphy_features_.supports_random_mac_oneshot_scan << endl;
|
|
*ss << "Device supports random MAC for scheduled scan: "
|
|
<< wiphy_features_.supports_random_mac_sched_scan << endl;
|
|
*ss << "------- Dump End -------" << endl;
|
|
}
|
|
|
|
bool ClientInterfaceImpl::EnableSupplicant() {
|
|
return supplicant_manager_->StartSupplicant();
|
|
}
|
|
|
|
bool ClientInterfaceImpl::DisableSupplicant() {
|
|
return supplicant_manager_->StopSupplicant();
|
|
}
|
|
|
|
bool ClientInterfaceImpl::GetPacketCounters(vector<int32_t>* out_packet_counters) {
|
|
StationInfo station_info;
|
|
if (!netlink_utils_->GetStationInfo(interface_index_,
|
|
bssid_,
|
|
&station_info)) {
|
|
return false;
|
|
}
|
|
out_packet_counters->push_back(station_info.station_tx_packets);
|
|
out_packet_counters->push_back(station_info.station_tx_failed);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ClientInterfaceImpl::SignalPoll(vector<int32_t>* out_signal_poll_results) {
|
|
if (!IsAssociated()) {
|
|
LOG(INFO) << "Fail RSSI polling because wifi is not associated.";
|
|
return false;
|
|
}
|
|
|
|
StationInfo station_info;
|
|
if (!netlink_utils_->GetStationInfo(interface_index_,
|
|
bssid_,
|
|
&station_info)) {
|
|
return false;
|
|
}
|
|
out_signal_poll_results->push_back(
|
|
static_cast<int32_t>(station_info.current_rssi));
|
|
// Convert from 100kbit/s to Mbps.
|
|
out_signal_poll_results->push_back(
|
|
static_cast<int32_t>(station_info.station_tx_bitrate/10));
|
|
// Association frequency.
|
|
out_signal_poll_results->push_back(
|
|
static_cast<int32_t>(associate_freq_));
|
|
|
|
return true;
|
|
}
|
|
|
|
const vector<uint8_t>& ClientInterfaceImpl::GetMacAddress() {
|
|
return interface_mac_addr_;
|
|
}
|
|
|
|
bool ClientInterfaceImpl::requestANQP(
|
|
const ::std::vector<uint8_t>& bssid,
|
|
const ::android::sp<::android::net::wifi::IANQPDoneCallback>& callback) {
|
|
// TODO(nywang): query ANQP information from wpa_supplicant.
|
|
return true;
|
|
}
|
|
|
|
bool ClientInterfaceImpl::RefreshAssociateFreq() {
|
|
// wpa_supplicant fetches associate frequency using the latest scan result.
|
|
// We should follow the same method here before we find a better solution.
|
|
std::vector<NativeScanResult> scan_results;
|
|
if (!scan_utils_->GetScanResult(interface_index_, &scan_results)) {
|
|
return false;
|
|
}
|
|
for (auto& scan_result : scan_results) {
|
|
if (scan_result.associated) {
|
|
associate_freq_ = scan_result.frequency;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ClientInterfaceImpl::IsAssociated() const {
|
|
return is_associated_;
|
|
}
|
|
|
|
} // namespace wificond
|
|
} // namespace android
|