Expose wiphy capabilities to ScannerImpl am: 2c74cae9b5 am: b88bfc01a0 am: d280e44922

am: 07748cdce0

Change-Id: I40f52c303a6a599c16cee58415ae517277413026

diff --git a/Android.mk b/Android.mk
index 8e6e922..df0b923 100644 (file)
--- a/Android.mk
+++ b/Android.mk
@@ -14,6 +14,8 @@
 
 LOCAL_PATH := $(call my-dir)
 wificond_cpp_flags := -std=c++11 -Wall -Werror -Wno-unused-parameter
+# TODO(b/33211652): Remove once ScannerImpl is fleshed out.
+wificond_cpp_flags += -Wno-unused-private-field
 wificond_parent_dir := $(LOCAL_PATH)/../
 wificond_includes := \
     $(wificond_parent_dir)

diff --git a/client_interface_impl.cpp b/client_interface_impl.cpp
index 0269612..9545e6d 100644 (file)
--- a/client_interface_impl.cpp
+++ b/client_interface_impl.cpp
@@ -71,6 +71,7 @@ void MlmeEventHandlerImpl::OnAssociate(unique_ptr<MlmeAssociateEvent> event) {
 }
 
 ClientInterfaceImpl::ClientInterfaceImpl(
+    uint32_t wiphy_index,
     const std::string& interface_name,
     uint32_t interface_index,
     const std::vector<uint8_t>& interface_mac_addr,
@@ -78,7 +79,8 @@ ClientInterfaceImpl::ClientInterfaceImpl(
     SupplicantManager* supplicant_manager,
     NetlinkUtils* netlink_utils,
     ScanUtils* scan_utils)
-    : interface_name_(interface_name),
+    : wiphy_index_(wiphy_index),
+      interface_name_(interface_name),
       interface_index_(interface_index),
       interface_mac_addr_(interface_mac_addr),
       if_tool_(if_tool),
@@ -86,11 +88,19 @@ ClientInterfaceImpl::ClientInterfaceImpl(
       netlink_utils_(netlink_utils),
       scan_utils_(scan_utils),
       mlme_event_handler_(new MlmeEventHandlerImpl(this)),
-      binder_(new ClientInterfaceBinder(this)),
-      scanner_(new ScannerImpl(interface_index, scan_utils)) {
+      binder_(new ClientInterfaceBinder(this)) {
   netlink_utils_->SubscribeMlmeEvent(
       interface_index_,
       mlme_event_handler_.get());
+  netlink_utils_->GetWiphyInfo(wiphy_index_,
+                               &band_info_,
+                               &scan_capabilities_,
+                               &wiphy_features_);
+  scanner_ = new ScannerImpl(interface_index_,
+                             band_info_,
+                             scan_capabilities_,
+                             wiphy_features_,
+                             scan_utils_);
 }
 
 ClientInterfaceImpl::~ClientInterfaceImpl() {

diff --git a/client_interface_impl.h b/client_interface_impl.h
index 31a368c..64b61c6 100644 (file)
--- a/client_interface_impl.h
+++ b/client_interface_impl.h
@@ -26,6 +26,7 @@
 
 #include "android/net/wifi/IClientInterface.h"
 #include "wificond/net/mlme_event_handler.h"
+#include "wificond/net/netlink_utils.h"
 #include "wificond/scanning/scanner_impl.h"
 
 namespace android {
@@ -33,7 +34,6 @@ namespace wificond {
 
 class ClientInterfaceBinder;
 class ClientInterfaceImpl;
-class NetlinkUtils;
 class ScanUtils;
 
 class MlmeEventHandlerImpl : public MlmeEventHandler {
@@ -57,6 +57,7 @@ class MlmeEventHandlerImpl : public MlmeEventHandler {
 class ClientInterfaceImpl {
  public:
   ClientInterfaceImpl(
+      uint32_t wiphy_index,
       const std::string& interface_name,
       uint32_t interface_index,
       const std::vector<uint8_t>& interface_mac_addr,
@@ -83,6 +84,7 @@ class ClientInterfaceImpl {
  private:
   bool RefreshAssociateFreq();
 
+  const uint32_t wiphy_index_;
   const std::string interface_name_;
   const uint32_t interface_index_;
   const std::vector<uint8_t> interface_mac_addr_;
@@ -92,11 +94,17 @@ class ClientInterfaceImpl {
   ScanUtils* const scan_utils_;
   const std::unique_ptr<MlmeEventHandlerImpl> mlme_event_handler_;
   const android::sp<ClientInterfaceBinder> binder_;
-  const android::sp<ScannerImpl> scanner_;
+  android::sp<ScannerImpl> scanner_;
 
+  // Cached information for this connection.
   std::vector<uint8_t> bssid_;
   uint32_t associate_freq_;
 
+  // Capability information for this wiphy/interface.
+  BandInfo band_info_;
+  ScanCapabilities scan_capabilities_;
+  WiphyFeatures wiphy_features_;
+
   DISALLOW_COPY_AND_ASSIGN(ClientInterfaceImpl);
   friend class MlmeEventHandlerImpl;
 };

diff --git a/net/netlink_utils.cpp b/net/netlink_utils.cpp
index 8a76149..559650b 100644 (file)
--- a/net/netlink_utils.cpp
+++ b/net/netlink_utils.cpp
@@ -177,7 +177,8 @@ bool NetlinkUtils::GetInterfaceInfo(uint32_t wiphy_index,
 bool NetlinkUtils::GetWiphyInfo(
     uint32_t wiphy_index,
     BandInfo* out_band_info,
-    ScanCapabilities* out_scan_capabilities) {
+    ScanCapabilities* out_scan_capabilities,
+    WiphyFeatures* out_wiphy_features) {
   NL80211Packet get_wiphy(
       netlink_manager_->GetFamilyId(),
       NL80211_CMD_GET_WIPHY,
@@ -199,6 +200,13 @@ bool NetlinkUtils::GetWiphyInfo(
       !ParseScanCapabilities(response.get(), out_scan_capabilities)) {
     return false;
   }
+  uint32_t feature_flags;
+  if (!response->GetAttributeValue(NL80211_ATTR_FEATURE_FLAGS,
+                                   &feature_flags)) {
+    LOG(ERROR) << "Failed to get NL80211_ATTR_FEATURE_FLAGS";
+    return false;
+  }
+  *out_wiphy_features = WiphyFeatures(feature_flags);
   return true;
 }
 

diff --git a/net/netlink_utils.h b/net/netlink_utils.h
index 02a813f..7fb2a2e 100644 (file)
--- a/net/netlink_utils.h
+++ b/net/netlink_utils.h
@@ -20,6 +20,8 @@
 #include <string>
 #include <vector>
 
+#include <linux/nl80211.h>
+
 #include <android-base/macros.h>
 
 namespace android {
@@ -57,6 +59,25 @@ struct ScanCapabilities {
   uint8_t max_match_sets;
 };
 
+struct WiphyFeatures {
+  WiphyFeatures()
+      : supports_random_mac_oneshot_scan(false),
+        supports_random_mac_sched_scan(false) {}
+  WiphyFeatures(uint32_t feature_flags)
+      : supports_random_mac_oneshot_scan(
+            feature_flags & NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR),
+        supports_random_mac_sched_scan(
+            feature_flags & NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR) {}
+  // This device/driver supports using a random MAC address during scan
+  // (while not associated).
+  bool supports_random_mac_oneshot_scan;
+  // This device/driver supports using a random MAC address for every
+  // scan iteration during scheduled scan (while not associated).
+  bool supports_random_mac_sched_scan;
+  // There are other flags included in NL80211_ATTR_FEATURE_FLAGS.
+  // We will add them once we find them useful.
+};
+
 struct StationInfo {
   StationInfo() = default;
   StationInfo(uint32_t station_tx_packets_,
@@ -102,14 +123,12 @@ class NetlinkUtils {
                                 uint32_t* index,
                                 std::vector<uint8_t>* mac_addr);
 
-  // Get wifi wiphy info from kernel.
-  // |*out_band_info| is the lists of frequencies in specific bands.
-  // |*out_scan_capabilities| is the lists of parameters specifying the
-  // scanning capability of underlying implementation.
+  // Get wiphy capability information from kernel.
   // Returns true on success.
   virtual bool GetWiphyInfo(uint32_t wiphy_index,
                             BandInfo* out_band_info,
-                            ScanCapabilities* out_scan_capabilities);
+                            ScanCapabilities* out_scan_capabilities,
+                            WiphyFeatures* out_wiphy_features);
 
   // Get station info from kernel.
   // |*out_station_info]| is the struct of available station information.

diff --git a/scanning/scanner_impl.cpp b/scanning/scanner_impl.cpp
index f962a6b..92b94d9 100644 (file)
--- a/scanning/scanner_impl.cpp
+++ b/scanning/scanner_impl.cpp
@@ -26,16 +26,16 @@ namespace android {
 namespace wificond {
 
 ScannerImpl::ScannerImpl(uint32_t interface_index,
+                         const BandInfo& band_info,
+                         const ScanCapabilities& scan_capabilities,
+                         const WiphyFeatures& wiphy_features,
                          ScanUtils* scan_utils)
     : valid_(true),
       interface_index_(interface_index),
+      band_info_(band_info),
+      scan_capabilities_(scan_capabilities),
+      wiphy_features_(wiphy_features),
       scan_utils_(scan_utils) {
-  // Keep compiler happy.
-  // Delete this when implementions are checked in.
-  if (scan_utils_ == nullptr) {
-    LOG(ERROR) << "Invalid ScanUtils for ScannerImpl on interface: "
-               << interface_index_;
-  }
 }
 
 ScannerImpl::~ScannerImpl() {

diff --git a/scanning/scanner_impl.h b/scanning/scanner_impl.h
index 975870d..9ea1333 100644 (file)
--- a/scanning/scanner_impl.h
+++ b/scanning/scanner_impl.h
@@ -23,6 +23,7 @@
 #include <binder/Status.h>
 
 #include "android/net/wifi/BnWifiScannerImpl.h"
+#include "wificond/net/netlink_utils.h"
 
 namespace android {
 namespace wificond {
@@ -31,7 +32,10 @@ class ScanUtils;
 
 class ScannerImpl : public android::net::wifi::BnWifiScannerImpl {
  public:
-  ScannerImpl(uint32_t interface_index_,
+  ScannerImpl(uint32_t interface_index,
+              const BandInfo& band_info,
+              const ScanCapabilities& scan_capabilities,
+              const WiphyFeatures& wiphy_features,
               ScanUtils* scan_utils_);
   ~ScannerImpl();
   void Invalidate() { valid_ = false; }
@@ -39,6 +43,12 @@ class ScannerImpl : public android::net::wifi::BnWifiScannerImpl {
  private:
   bool valid_;
   uint32_t interface_index_;
+
+  // Scanning relevant capability information for this wiphy/interface.
+  const BandInfo band_info_;
+  const ScanCapabilities scan_capabilities_;
+  const WiphyFeatures wiphy_features_;
+
   ScanUtils* scan_utils_;
 
   DISALLOW_COPY_AND_ASSIGN(ScannerImpl);

diff --git a/server.cpp b/server.cpp
index d655d71..e12dd18 100644 (file)
--- a/server.cpp
+++ b/server.cpp
@@ -138,6 +138,7 @@ Status Server::createClientInterface(sp<IClientInterface>* created_interface) {
   }
 
   unique_ptr<ClientInterfaceImpl> client_interface(new ClientInterfaceImpl(
+      wiphy_index_,
       interface_name,
       interface_index,
       interface_mac_addr,

diff --git a/tests/client_interface_impl_unittest.cpp b/tests/client_interface_impl_unittest.cpp
index 97d28f7..df6884e 100644 (file)
--- a/tests/client_interface_impl_unittest.cpp
+++ b/tests/client_interface_impl_unittest.cpp
@@ -41,6 +41,7 @@ namespace android {
 namespace wificond {
 namespace {
 
+const uint32_t kTestWiphyIndex = 2;
 const char kTestInterfaceName[] = "testwifi0";
 const uint32_t kTestInterfaceIndex = 42;
 
@@ -48,17 +49,24 @@ class ClientInterfaceImplTest : public ::testing::Test {
  protected:
 
   void SetUp() override {
+    EXPECT_CALL(*netlink_utils_,
+                SubscribeMlmeEvent(kTestInterfaceIndex, _));
+    EXPECT_CALL(*netlink_utils_,
+                GetWiphyInfo(kTestWiphyIndex, _, _, _));
     client_interface_.reset(new ClientInterfaceImpl{
+        kTestWiphyIndex,
         kTestInterfaceName,
         kTestInterfaceIndex,
         vector<uint8_t>{0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
         if_tool_.get(),
         supplicant_manager_.get(),
-        &netlink_utils_,
-        &scan_utils_});
+        netlink_utils_.get(),
+        scan_utils_.get()});
   }
 
   void TearDown() override {
+    EXPECT_CALL(*netlink_utils_,
+                UnsubscribeMlmeEvent(kTestInterfaceIndex));
     EXPECT_CALL(*supplicant_manager_, StopSupplicant())
         .WillOnce(Return(false));
   }
@@ -69,8 +77,10 @@ class ClientInterfaceImplTest : public ::testing::Test {
       new NiceMock<MockSupplicantManager>};
   unique_ptr<NiceMock<MockNetlinkManager>> netlink_manager_{
       new NiceMock<MockNetlinkManager>()};
-  MockNetlinkUtils netlink_utils_{netlink_manager_.get()};
-  MockScanUtils scan_utils_{netlink_manager_.get()};
+  unique_ptr<NiceMock<MockNetlinkUtils>> netlink_utils_{
+      new NiceMock<MockNetlinkUtils>(netlink_manager_.get())};
+  unique_ptr<NiceMock<MockScanUtils>> scan_utils_{
+      new NiceMock<MockScanUtils>(netlink_manager_.get())};
   unique_ptr<ClientInterfaceImpl> client_interface_;
 };  // class ClientInterfaceImplTest
 

diff --git a/tests/mock_netlink_utils.h b/tests/mock_netlink_utils.h
index 806da7f..4d1e8c5 100644 (file)
--- a/tests/mock_netlink_utils.h
+++ b/tests/mock_netlink_utils.h
@@ -30,11 +30,20 @@ class MockNetlinkUtils : public NetlinkUtils {
   ~MockNetlinkUtils() override = default;
 
   MOCK_METHOD1(GetWiphyIndex, bool(uint32_t* out_wiphy_index));
+  MOCK_METHOD1(UnsubscribeMlmeEvent, void(uint32_t interface_index));
+  MOCK_METHOD2(SubscribeMlmeEvent,
+               void(uint32_t interface_index,
+                    MlmeEventHandler* handler));
   MOCK_METHOD4(GetInterfaceInfo,
                bool(uint32_t wiphy_index,
                     std::string* name,
                     uint32_t* index,
                     std::vector<uint8_t>* mac_address));
+  MOCK_METHOD4(GetWiphyInfo,
+               bool(uint32_t wiphy_index,
+                    BandInfo* band_info,
+                    ScanCapabilities* scan_capabilities,
+                    WiphyFeatures* wiphy_features));
 
 };  // class MockNetlinkUtils