scanning/scan_result.cpp

/*
 * 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/scanning/scan_result.h"

#include <algorithm>

#include <android-base/logging.h>

#include "wificond/logging_utils.h"
#include "wificond/parcelable_utils.h"

using android::status_t;
using android::OK;
using std::string;

namespace android {
namespace net {
namespace wifi {
namespace nl80211 {

NativeScanResult::NativeScanResult(std::vector<uint8_t>& ssid_,
                                   std::array<uint8_t, ETH_ALEN>& bssid_,
                                   std::vector<uint8_t>& info_element_,
                                   uint32_t frequency_,
                                   int32_t signal_mbm_,
                                   uint64_t tsf_,
                                   uint16_t capability_,
                                   bool associated_,
                                   std::vector<RadioChainInfo>& radio_chain_infos_)
    : ssid(ssid_),
      bssid(bssid_),
      info_element(info_element_),
      frequency(frequency_),
      signal_mbm(signal_mbm_),
      tsf(tsf_),
      capability(capability_),
      associated(associated_),
      radio_chain_infos(radio_chain_infos_) {
}

status_t NativeScanResult::writeToParcel(::android::Parcel* parcel) const {
  RETURN_IF_FAILED(parcel->writeByteVector(ssid));
  RETURN_IF_FAILED(parcel->writeByteVector(
      std::vector<uint8_t>(bssid.begin(), bssid.end())));
  RETURN_IF_FAILED(parcel->writeByteVector(info_element));
  RETURN_IF_FAILED(parcel->writeUint32(frequency));
  RETURN_IF_FAILED(parcel->writeInt32(signal_mbm));
  RETURN_IF_FAILED(parcel->writeUint64(tsf));
  // There is no writeUint16() available.
  // Use writeUint32() instead.
  RETURN_IF_FAILED(parcel->writeUint32(capability));
  RETURN_IF_FAILED(parcel->writeInt32(associated ? 1 : 0));
  RETURN_IF_FAILED(parcel->writeInt32(radio_chain_infos.size()));
  for (const auto& radio_chain_info : radio_chain_infos) {
    // For Java readTypedList():
    // A leading number 1 means this object is not null.
    RETURN_IF_FAILED(parcel->writeInt32(1));
    RETURN_IF_FAILED(radio_chain_info.writeToParcel(parcel));
  }
  return ::android::OK;
}

status_t NativeScanResult::readFromParcel(const ::android::Parcel* parcel) {
  RETURN_IF_FAILED(parcel->readByteVector(&ssid));
  {
    std::vector<uint8_t> bssid_vec;
    RETURN_IF_FAILED(parcel->readByteVector(&bssid_vec));
    if (bssid_vec.size() != ETH_ALEN) {
      LOG(ERROR) << "bssid length expected " << ETH_ALEN << " bytes, but got "
                 << bssid_vec.size() << " bytes";
      return ::android::BAD_VALUE;
    }
    std::copy_n(bssid_vec.begin(), ETH_ALEN, bssid.begin());
  }
  RETURN_IF_FAILED(parcel->readByteVector(&info_element));
  RETURN_IF_FAILED(parcel->readUint32(&frequency));
  RETURN_IF_FAILED(parcel->readInt32(&signal_mbm));
  RETURN_IF_FAILED(parcel->readUint64(&tsf));
  // There is no readUint16() available.
  // Use readUint32() instead.
  capability = static_cast<uint16_t>(parcel->readUint32());
  associated = (parcel->readInt32() != 0);
  int32_t num_radio_chain_infos = 0;
  RETURN_IF_FAILED(parcel->readInt32(&num_radio_chain_infos));
  for (int i = 0; i < num_radio_chain_infos; i++) {
    RadioChainInfo radio_chain_info;
    // From Java writeTypedList():
    // A leading number 1 means this object is not null.
    // We never expect a 0 or other values here.
    int32_t leading_number = 0;
    RETURN_IF_FAILED(parcel->readInt32(&leading_number));
    if (leading_number != 1) {
      LOG(ERROR) << "Unexpected leading number before an object: "
                 << leading_number;
      return ::android::BAD_VALUE;
    }
    RETURN_IF_FAILED(radio_chain_info.readFromParcel(parcel));
    radio_chain_infos.push_back(radio_chain_info);
  }
  return ::android::OK;
}

void NativeScanResult::DebugLog() {
  LOG(INFO) << "Scan result:";
  // |ssid| might be an encoded array but we just print it as ASCII here.
  string ssid_str(ssid.data(), ssid.data() + ssid.size());
  LOG(INFO) << "SSID: " << ssid_str;

  LOG(INFO) << "BSSID: "
            << ::android::wificond::LoggingUtils::GetMacString(bssid);
  LOG(INFO) << "FREQUENCY: " << frequency;
  LOG(INFO) << "SIGNAL: " << signal_mbm/100 << "dBm";
  LOG(INFO) << "TSF: " << tsf;
  LOG(INFO) << "CAPABILITY: " << capability;
  LOG(INFO) << "ASSOCIATED: " << associated;
  for (const auto& radio_chain_info : radio_chain_infos) {
    LOG(INFO) << "RADIO CHAIN ID: " << radio_chain_info.chain_id;
    LOG(INFO) << "RADIO CHAIN LEVEL: " << radio_chain_info.level;
  }

}

}  // namespace nl80211
}  // namespace wifi
}  // namespace net
}  // namespace android