Add vendor ies in scan probe req

Bug: 258285219
Test: manually verified the vendor ies in sniffer probe req pkt.
Change-Id: I280e0e122d250d8f3aa749a9e7cec6d75b2c3f8f

8 files changed, 38 insertions, 22 deletions

diff --git a/scanning/scan_utils.cpp b/scanning/scan_utils.cpp
index 6c2cb22..8c79b20 100644
--- a/scanning/scan_utils.cpp
+++ b/scanning/scan_utils.cpp
@@ -281,6 +281,7 @@ bool ScanUtils::Scan(uint32_t interface_index,
                      bool enable_6ghz_rnr,
                      const vector<vector<uint8_t>>& ssids,
                      const vector<uint32_t>& freqs,
+                     const vector<uint8_t>& vendor_ies,
                      int* error_code) {
   NL80211Packet trigger_scan(
       netlink_manager_->GetFamilyId(),
@@ -341,6 +342,12 @@ bool ScanUtils::Scan(uint32_t interface_index,
                               scan_flags));
     LOG(DEBUG) << "Triggering scan with scan_flag=" << scan_flags;
   }
+
+  if (!vendor_ies.empty()) {
+    NL80211Attr<vector<uint8_t>> vendor_ie_attr(NL80211_ATTR_IE, vendor_ies);
+    trigger_scan.AddAttribute(vendor_ie_attr);
+  }
+
   // 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.
diff --git a/scanning/scan_utils.h b/scanning/scan_utils.h
index 3ac7f4a..2d4cfe3 100644
--- a/scanning/scan_utils.h
+++ b/scanning/scan_utils.h
@@ -94,6 +94,7 @@ class ScanUtils {
   // If |ssids| contains an empty string, it will a scan for all ssids.
   // - |freqs| is a vector of frequencies we request to scan.
   // If |freqs| is an empty vector, it will scan all supported frequencies.
+  // - |vendor_ies| is a vector of vendor ies we add it in probe req.
   // - |error_code| contains the errno kernel replied when this returns false.
   // Returns true on success.
   virtual bool Scan(uint32_t interface_index,
@@ -102,6 +103,7 @@ class ScanUtils {
                     bool enable_6ghz_rnr,
                     const std::vector<std::vector<uint8_t>>& ssids,
                     const std::vector<uint32_t>& freqs,
+                    const std::vector<uint8_t>& vendor_ies,
                     int* error_code);
 
   // Send scan request to kernel for interface with index |interface_index|.
diff --git a/scanning/scanner_impl.cpp b/scanning/scanner_impl.cpp
index e003aa7..c9e2eee 100644
--- a/scanning/scanner_impl.cpp
+++ b/scanning/scanner_impl.cpp
@@ -204,7 +204,8 @@ Status ScannerImpl::scanRequest(const SingleScanSettings& scan_settings,
 
   int error_code = 0;
   if (!scan_utils_->Scan(interface_index_, request_random_mac, scan_type,
-                         scan_settings.enable_6ghz_rnr_, ssids, freqs, &error_code)) {
+                         scan_settings.enable_6ghz_rnr_, ssids, freqs,
+                         scan_settings.vendor_ies_, &error_code)) {
     if (error_code == ENODEV) {
         nodev_counter_ ++;
         LOG(WARNING) << "Scan failed with error=nodev. counter=" << nodev_counter_;
diff --git a/scanning/single_scan_settings.cpp b/scanning/single_scan_settings.cpp
index 47809fb..28dad53 100644
--- a/scanning/single_scan_settings.cpp
+++ b/scanning/single_scan_settings.cpp
@@ -55,6 +55,7 @@ status_t SingleScanSettings::writeToParcel(::android::Parcel* parcel) const {
     RETURN_IF_FAILED(parcel->writeInt32(1));
     RETURN_IF_FAILED(network.writeToParcel(parcel));
   }
+  RETURN_IF_FAILED(parcel->writeByteVector(vendor_ies_));
   return ::android::OK;
 }
 
@@ -107,6 +108,7 @@ status_t SingleScanSettings::readFromParcel(const ::android::Parcel* parcel) {
     RETURN_IF_FAILED(network.readFromParcel(parcel));
     hidden_networks_.push_back(network);
   }
+  RETURN_IF_FAILED(parcel->readByteVector(&vendor_ies_));
   return ::android::OK;
 }
 
diff --git a/scanning/single_scan_settings.h b/scanning/single_scan_settings.h
index a7d99dd..27bf774 100644
--- a/scanning/single_scan_settings.h
+++ b/scanning/single_scan_settings.h
@@ -36,7 +36,8 @@ class SingleScanSettings : public ::android::Parcelable {
   bool operator==(const SingleScanSettings& rhs) const {
     return (scan_type_ == rhs.scan_type_ &&
             channel_settings_ == rhs.channel_settings_ &&
-            hidden_networks_ == rhs.hidden_networks_);
+            hidden_networks_ == rhs.hidden_networks_ &&
+            vendor_ies_ == rhs.vendor_ies_);
   }
   ::android::status_t writeToParcel(::android::Parcel* parcel) const override;
   ::android::status_t readFromParcel(const ::android::Parcel* parcel) override;
@@ -45,6 +46,7 @@ class SingleScanSettings : public ::android::Parcelable {
   bool enable_6ghz_rnr_;
   std::vector<ChannelSettings> channel_settings_;
   std::vector<HiddenNetwork> hidden_networks_;
+  std::vector<uint8_t> vendor_ies_;
 
  private:
   bool isValidScanType() const;
diff --git a/tests/mock_scan_utils.h b/tests/mock_scan_utils.h
index 3f43bb2..1c6ccc3 100644
--- a/tests/mock_scan_utils.h
+++ b/tests/mock_scan_utils.h
@@ -41,13 +41,14 @@ class MockScanUtils : public ScanUtils {
       uint32_t interface_index,
       std::vector<android::net::wifi::nl80211::NativeScanResult>* out_scan_results));
 
-  MOCK_METHOD7(Scan, bool(
+  MOCK_METHOD8(Scan, bool(
       uint32_t interface_index,
       bool request_random_mac,
       int scan_type,
       bool enable_6ghz_rnr,
       const std::vector<std::vector<uint8_t>>& ssids,
       const std::vector<uint32_t>& freqs,
+      const std::vector<uint8_t>& vendor_ies,
       int* error_code));
 
   MOCK_METHOD10(StartScheduledScan, bool(
diff --git a/tests/scan_utils_unittest.cpp b/tests/scan_utils_unittest.cpp
index d2f3631..e2eb414 100644
--- a/tests/scan_utils_unittest.cpp
+++ b/tests/scan_utils_unittest.cpp
@@ -155,7 +155,7 @@ TEST_F(ScanUtilsTest, CanSendScanRequest) {
                   AppendMessageAndReturn, response, true, _1, _2)));
   int errno_ignored;
   EXPECT_TRUE(scan_utils_.Scan(kFakeInterfaceIndex, kFakeUseRandomMAC,
-                               kFakeScanType, false, {}, {}, &errno_ignored));
+                               kFakeScanType, false, {}, {}, {}, &errno_ignored));
   // TODO(b/34231420): Add validation of requested scan ssids, threshold,
   // and frequencies.
 }
@@ -175,7 +175,7 @@ TEST_F(ScanUtilsTest, CanSendScanRequestWithRandomAddr) {
   int errno_ignored;
   EXPECT_TRUE(scan_utils_.Scan(kFakeInterfaceIndex, true,
                                IWifiScannerImpl::SCAN_TYPE_DEFAULT,
-                               false, {}, {}, &errno_ignored));
+                               false, {}, {}, {}, &errno_ignored));
 }
 
 TEST_F(ScanUtilsTest, CanSendScanRequestForLowSpanScan) {
@@ -195,7 +195,7 @@ TEST_F(ScanUtilsTest, CanSendScanRequestForLowSpanScan) {
   int errno_ignored;
   EXPECT_TRUE(scan_utils_.Scan(kFakeInterfaceIndex, false,
                                IWifiScannerImpl::SCAN_TYPE_LOW_SPAN,
-                               true, {}, {}, &errno_ignored));
+                               true, {}, {}, {}, &errno_ignored));
 }
 
 TEST_F(ScanUtilsTest, CanSendScanRequestForLowPowerScan) {
@@ -213,7 +213,7 @@ TEST_F(ScanUtilsTest, CanSendScanRequestForLowPowerScan) {
   int errno_ignored;
   EXPECT_TRUE(scan_utils_.Scan(kFakeInterfaceIndex, false,
                                IWifiScannerImpl::SCAN_TYPE_LOW_POWER,
-                               false, {}, {}, &errno_ignored));
+                               false, {}, {}, {}, &errno_ignored));
 }
 
 TEST_F(ScanUtilsTest, CanSendScanRequestForHighAccuracyScan) {
@@ -231,7 +231,7 @@ TEST_F(ScanUtilsTest, CanSendScanRequestForHighAccuracyScan) {
   int errno_ignored;
   EXPECT_TRUE(scan_utils_.Scan(kFakeInterfaceIndex, false,
                                IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY,
-                               false, {}, {}, &errno_ignored));
+                               false, {}, {}, {}, &errno_ignored));
 }
 
 TEST_F(ScanUtilsTest, CanSendScanRequestForHighAccuracyScanWithRandomAddr) {
@@ -251,7 +251,7 @@ TEST_F(ScanUtilsTest, CanSendScanRequestForHighAccuracyScanWithRandomAddr) {
   int errno_ignored;
   EXPECT_TRUE(scan_utils_.Scan(kFakeInterfaceIndex, true,
                                IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY,
-                               false, {}, {}, &errno_ignored));
+                               false, {}, {}, {}, &errno_ignored));
 }
 
 TEST_F(ScanUtilsTest, CanHandleScanRequestFailure) {
@@ -264,7 +264,7 @@ TEST_F(ScanUtilsTest, CanHandleScanRequestFailure) {
                   AppendMessageAndReturn, response, true, _1, _2)));
   int error_code;
   EXPECT_FALSE(scan_utils_.Scan(kFakeInterfaceIndex, kFakeUseRandomMAC,
-                               kFakeScanType, false, {}, {}, &error_code));
+                               kFakeScanType, false, {}, {}, {}, &error_code));
   EXPECT_EQ(kFakeErrorCode, error_code);
 }
 
diff --git a/tests/scanner_unittest.cpp b/tests/scanner_unittest.cpp
index 869a21b..8a5209b 100644
--- a/tests/scanner_unittest.cpp
+++ b/tests/scanner_unittest.cpp
@@ -67,6 +67,7 @@ bool ReturnErrorCodeForScanRequest(
     bool enable_6ghz_rnr,
     const std::vector<std::vector<uint8_t>>& ssids_ignored,
     const std::vector<uint32_t>& freqs_ignored,
+    const std::vector<uint8_t>& vendor_ies,
     int* error_code) {
   *error_code = mock_error_code;
   // Returing false because this helper function is used for failure case.
@@ -121,7 +122,7 @@ class ScannerTest : public ::testing::Test {
 
 TEST_F(ScannerTest, TestSingleScan) {
   EXPECT_CALL(scan_utils_,
-              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, false, _, _, _)).
+              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, false, _, _, _, _)).
       WillOnce(Return(true));
   bool success = false;
   scanner_impl_.reset(new ScannerImpl(kFakeInterfaceIndex,
@@ -134,7 +135,7 @@ TEST_F(ScannerTest, TestSingleScan) {
 
 TEST_F(ScannerTest, TestSingleScanForLowSpanScan) {
   EXPECT_CALL(scan_utils_,
-              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_SPAN, true, _, _, _)).
+              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_SPAN, true, _, _, _, _)).
       WillOnce(Return(true));
   wiphy_features_.supports_low_span_oneshot_scan = true;
   ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
@@ -150,7 +151,7 @@ TEST_F(ScannerTest, TestSingleScanForLowSpanScan) {
 
 TEST_F(ScannerTest, TestSingleScanForLowPowerScan) {
   EXPECT_CALL(scan_utils_,
-              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_POWER, _, _, _, _)).
+              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_LOW_POWER, _, _, _, _, _)).
       WillOnce(Return(true));
   wiphy_features_.supports_low_power_oneshot_scan = true;
   ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
@@ -165,7 +166,7 @@ TEST_F(ScannerTest, TestSingleScanForLowPowerScan) {
 
 TEST_F(ScannerTest, TestSingleScanForHighAccuracyScan) {
   EXPECT_CALL(scan_utils_,
-              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY, _, _, _, _)).
+              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_HIGH_ACCURACY, _, _, _, _, _)).
       WillOnce(Return(true));
   wiphy_features_.supports_high_accuracy_oneshot_scan = true;
   ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
@@ -180,7 +181,7 @@ TEST_F(ScannerTest, TestSingleScanForHighAccuracyScan) {
 
 TEST_F(ScannerTest, TestSingleScanForLowSpanScanWithNoWiphySupport) {
   EXPECT_CALL(scan_utils_,
-              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _, _)).
+              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _, _, _)).
       WillOnce(Return(true));
   ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
                            wiphy_features_, &client_interface_impl_,
@@ -194,7 +195,7 @@ TEST_F(ScannerTest, TestSingleScanForLowSpanScanWithNoWiphySupport) {
 
 TEST_F(ScannerTest, TestSingleScanForLowPowerScanWithNoWiphySupport) {
   EXPECT_CALL(scan_utils_,
-              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _, _)).
+              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _, _, _)).
       WillOnce(Return(true));
   ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
                            wiphy_features_, &client_interface_impl_,
@@ -208,7 +209,7 @@ TEST_F(ScannerTest, TestSingleScanForLowPowerScanWithNoWiphySupport) {
 
 TEST_F(ScannerTest, TestSingleScanForHighAccuracyScanWithNoWiphySupport) {
   EXPECT_CALL(scan_utils_,
-              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _, _)).
+              Scan(_, _, IWifiScannerImpl::SCAN_TYPE_DEFAULT, _, _, _, _, _)).
       WillOnce(Return(true));
   ScannerImpl scanner_impl(kFakeInterfaceIndex, scan_capabilities_,
                            wiphy_features_, &client_interface_impl_,
@@ -227,10 +228,10 @@ TEST_F(ScannerTest, TestSingleScanFailure) {
                                       &scan_utils_));
   EXPECT_CALL(
       scan_utils_,
-      Scan(_, _, _, _, _, _, _)).
+      Scan(_, _, _, _, _, _, _, _)).
           WillOnce(Invoke(bind(
               ReturnErrorCodeForScanRequest, EBUSY,
-              _1, _2, _3, _4, _5, _6, _7)));
+              _1, _2, _3, _4, _5, _6, _7, _8)));
 
   bool success = false;
   EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &success).isOk());
@@ -244,10 +245,10 @@ TEST_F(ScannerTest, TestProcessAbortsOnScanReturningNoDeviceErrorSeveralTimes) {
                                       &scan_utils_));
   ON_CALL(
       scan_utils_,
-      Scan(_, _, _, _, _, _, _)).
+      Scan(_, _, _, _, _, _, _, _)).
           WillByDefault(Invoke(bind(
               ReturnErrorCodeForScanRequest, ENODEV,
-              _1, _2, _3, _4, _5, _6, _7)));
+              _1, _2, _3, _4, _5, _6, _7, _8)));
 
   bool single_scan_failure;
   EXPECT_TRUE(scanner_impl_->scan(SingleScanSettings(), &single_scan_failure).isOk());
@@ -266,7 +267,7 @@ TEST_F(ScannerTest, TestAbortScan) {
                                       scan_capabilities_, wiphy_features_,
                                       &client_interface_impl_,
                                       &scan_utils_));
-  EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _, _, _)).WillOnce(Return(true));
+  EXPECT_CALL(scan_utils_, Scan(_, _, _, _, _, _, _, _)).WillOnce(Return(true));
   EXPECT_TRUE(
       scanner_impl_->scan(SingleScanSettings(), &single_scan_success).isOk());
   EXPECT_TRUE(single_scan_success);