/*
* 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.
*/
#ifndef WIFICOND_NET_NL80211_ATTRIBUTE_H_
#define WIFICOND_NET_NL80211_ATTRIBUTE_H_
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
#include <linux/netlink.h>
#include <android-base/logging.h>
#include <android-base/macros.h>
namespace android {
namespace wificond {
class BaseNL80211Attr {
public:
BaseNL80211Attr(int id, const std::vector<uint8_t>& raw_buffer);
virtual ~BaseNL80211Attr() = default;
const std::vector<uint8_t>& GetConstData() const;
int GetAttributeId() const;
// This is used when we initialize a NL80211 attribute from an existing
// buffer.
virtual bool IsValid() const;
// A util helper function to find a specific sub attribute from a buffer.
// This buffer is supposed to be from a nested attribute or a nl80211 packet.
// |*start| and |*end| are the start and end pointers of buffer where
// |id| atrribute locates.
static bool GetAttributeImpl(const uint8_t* buf,
size_t len,
int attr_id,
uint8_t** attr_start,
uint8_t** attr_end);
// Merge the payload of |attr| to current attribute.
// This is only used for merging attribute from the response of split dump.
// Returns true on success.
bool Merge(const BaseNL80211Attr& attr);
protected:
BaseNL80211Attr() = default;
void InitHeaderAndResize(int attribute_id, int payload_length);
std::vector<uint8_t> data_;
};
template <typename T>
class NL80211Attr : public BaseNL80211Attr {
public:
NL80211Attr(int id, T value) {
static_assert(
std::is_integral<T>::value,
"Failed to create NL80211Attr class with non-integral type");
InitHeaderAndResize(id, sizeof(T));
T* storage = reinterpret_cast<T*>(data_.data() + NLA_HDRLEN);
*storage = value;
}
// Caller is responsible for ensuring that |data| is:
// 1) Is at least NLA_HDRLEN long.
// 2) That *data when interpreted as a nlattr is internally consistent.
// (e.g. data.size() == NLA_ALIGN(nlattr.nla_len)
// and nla_len == NLA_HDRLEN + payload size
explicit NL80211Attr(const std::vector<uint8_t>& data) {
data_ = data;
}
~NL80211Attr() override = default;
bool IsValid() const override {
if (!BaseNL80211Attr::IsValid()) {
return false;
}
// If BaseNL80211Attr::IsValid() == true, at least we have enough valid
// buffer for header.
const nlattr* header = reinterpret_cast<const nlattr*>(data_.data());
// Buffer size = header size + payload size + padding size
// nla_len = header size + payload size
if (NLA_ALIGN(sizeof(T)) + NLA_HDRLEN != data_.size() ||
sizeof(T) + NLA_HDRLEN != header->nla_len ) {
return false;
}
return true;
}
T GetValue() const {
return *reinterpret_cast<const T*>(data_.data() + NLA_HDRLEN);
}
}; // class NL80211Attr for POD-types
template <>
class NL80211Attr<std::vector<uint8_t>> : public BaseNL80211Attr {
public:
NL80211Attr(int id, const std::vector<uint8_t>& raw_buffer);
explicit NL80211Attr(const std::vector<uint8_t>& data);
~NL80211Attr() override = default;
std::vector<uint8_t> GetValue() const;
}; // class NL80211Attr for raw data
template <size_t N>
class NL80211Attr<std::array<uint8_t, N>> : public BaseNL80211Attr {
public:
NL80211Attr(int id, const std::array<uint8_t, N>& raw_buffer)
: BaseNL80211Attr(
id, std::vector<uint8_t>(raw_buffer.begin(), raw_buffer.end())) {}
explicit NL80211Attr(const std::vector<uint8_t>& data) {
data_ = data;
}
~NL80211Attr() override = default;
std::array<uint8_t, N> GetValue() const {
std::array<uint8_t, N> arr;
std::copy_n(data_.data() + NLA_HDRLEN, N, arr.begin());
return arr;
}
}; // class NL80211Attr for fixed size array
template <>
class NL80211Attr<std::string> : public BaseNL80211Attr {
public:
NL80211Attr(int id, const std::string& str);
// We parse string attribute buffer in the same way kernel does.
// All trailing zeros are trimmed when retrieving a std::string from
// byte array.
explicit NL80211Attr(const std::vector<uint8_t>& data);
~NL80211Attr() override = default;
std::string GetValue() const;
}; // class NL80211Attr for string
// Force the compiler not to instantiate these templates because
// they will be instantiated in nl80211_attribute.cpp file. This helps
// reduce compile time as well as object file size.
extern template class NL80211Attr<uint8_t>;
extern template class NL80211Attr<uint16_t>;
extern template class NL80211Attr<uint32_t>;
extern template class NL80211Attr<uint64_t>;
extern template class NL80211Attr<std::vector<uint8_t>>;
extern template class NL80211Attr<std::string>;
class NL80211NestedAttr : public BaseNL80211Attr {
public:
explicit NL80211NestedAttr(int id);
explicit NL80211NestedAttr(const std::vector<uint8_t>& data);
~NL80211NestedAttr() override = default;
void AddAttribute(const BaseNL80211Attr& attribute);
// For NLA_FLAG attribute
void AddFlagAttribute(int attribute_id);
bool HasAttribute(int id) const;
// Access an attribute nested within |this|.
// The result is returned by writing the attribute object to |*attribute|.
// Deeper nested attributes are not included. This means if A is nested within
// |this|, and B is nested within A, this function can't be used to access B.
// The reason is that we may have multiple attributes having the same
// attribute id, nested within different level of |this|.
bool GetAttribute(int id, NL80211NestedAttr* attribute) const;
template <typename T>
bool GetAttributeValue(int id, T* value) const {
std::vector<uint8_t> empty_vec;
// All data in |attribute| created here will be overwritten by
// GetAttribute(). So we use an empty vector to initialize it,
// regardless of the fact that an empty buffer is not qualified
// for creating a valid attribute.
NL80211Attr<T> attribute(empty_vec);
if (!GetAttribute(id, &attribute)) {
return false;
}
*value = attribute.GetValue();
return true;
}
// Some of the nested attribute contains a list of same type sub-attributes.
// This function retrieves a vector of attribute values from a nested
// attribute.
//
// This is for both correctness and performance reasons: Refer to
// GetListOfAttributes().
//
// Returns true on success.
template <typename T>
bool GetListOfAttributeValues(std::vector<T>* value) const {
const uint8_t* ptr = data_.data() + NLA_HDRLEN;
const uint8_t* end_ptr = data_.data() + data_.size();
std::vector<T> attr_list;
while (ptr + NLA_HDRLEN <= end_ptr) {
const nlattr* header = reinterpret_cast<const nlattr*>(ptr);
if (ptr + NLA_ALIGN(header->nla_len) > end_ptr) {
LOG(ERROR) << "Failed to get list of attributes: invalid nla_len.";
return false;
}
NL80211Attr<T> attribute(std::vector<uint8_t>(
ptr,
ptr + NLA_ALIGN(header->nla_len)));
if (!attribute.IsValid()) {
return false;
}
attr_list.emplace_back(attribute.GetValue());
ptr += NLA_ALIGN(header->nla_len);
}
*value = std::move(attr_list);
return true;
}
// Some of the nested attribute contains a list of same type sub-attributes.
// This function retrieves a vector of attributes from a nested
// attribute.
//
// This is for both correctness and performance reasons:
// Correctness reason:
// These sub-attributes have attribute id from '0 to n' or '1 to n'.
// There is no document defining what the start index should be.
//
// Performance reson:
// Calling GetAttribute() from '0 to n' results a n^2 time complexity.
// This function get a list of attributes in one pass.
//
// Returns true on success.
template <typename T>
bool GetListOfAttributes(std::vector<NL80211Attr<T>>* value) const {
const uint8_t* ptr = data_.data() + NLA_HDRLEN;
const uint8_t* end_ptr = data_.data() + data_.size();
std::vector<NL80211Attr<T>> attr_list;
while (ptr + NLA_HDRLEN <= end_ptr) {
const nlattr* header = reinterpret_cast<const nlattr*>(ptr);
if (ptr + NLA_ALIGN(header->nla_len) > end_ptr) {
LOG(ERROR) << "Failed to get list of attributes: invalid nla_len.";
return false;
}
NL80211Attr<T> attribute(std::vector<uint8_t>(
ptr,
ptr + NLA_ALIGN(header->nla_len)));
if (!attribute.IsValid()) {
return false;
}
attr_list.emplace_back(attribute);
ptr += NLA_ALIGN(header->nla_len);
}
*value = std::move(attr_list);
return true;
}
// This is similar to |GetListOfAttributeValues|, but for the cases where all
// the sub-attributes are nested attributes.
bool GetListOfNestedAttributes(std::vector<NL80211NestedAttr>* value) const;
template <typename T>
bool GetAttribute(int id, NL80211Attr<T>* attribute) const {
uint8_t* start = nullptr;
uint8_t* end = nullptr;
if (!BaseNL80211Attr::GetAttributeImpl(data_.data() + NLA_HDRLEN,
data_.size() - NLA_HDRLEN,
id, &start, &end) ||
start == nullptr ||
end == nullptr) {
return false;
}
*attribute = NL80211Attr<T>(std::vector<uint8_t>(start, end));
if (!attribute->IsValid()) {
return false;
}
return true;
}
void DebugLog() const;
};
} // namespace wificond
} // namespace android
#endif // WIFICOND_NET_NL80211_ATTRIBUTE_H_