net/nl80211_attribute.h

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef WIFICOND_NET_NL80211_ATTRIBUTE_H_
  18 #define WIFICOND_NET_NL80211_ATTRIBUTE_H_
  19
  20 #include <memory>
  21 #include <string>
  22 #include <type_traits>
  23 #include <vector>
  24
  25 #include <linux/netlink.h>
  26
  27 #include <android-base/logging.h>
  28 #include <android-base/macros.h>
  29
  30 namespace android {
  31 namespace wificond {
  32
  33 class BaseNL80211Attr {
  34  public:
  35   virtual ~BaseNL80211Attr() = default;
  36
  37   const std::vector<uint8_t>& GetConstData() const;
  38   int GetAttributeId() const;
  39   // This is used when we initialize a NL80211 attribute from an existing
  40   // buffer.
  41   virtual bool IsValid() const;
  42   // A util helper function to find a specific sub attribute from a buffer.
  43   // This buffer is supposed to be from a nested attribute or a nl80211 packet.
  44   // |*start| and |*end| are the start and end pointers of buffer where
  45   // |id| atrribute locates.
  46   static bool GetAttributeImpl(const uint8_t* buf,
  47                               size_t len,
  48                               int attr_id,
  49                               uint8_t** attr_start,
  50                               uint8_t** attr_end);
  51
  52  protected:
  53   BaseNL80211Attr() = default;
  54   void InitHeaderAndResize(int attribute_id, int payload_length);
  55
  56   std::vector<uint8_t> data_;
  57 };
  58
  59 template <typename T>
  60 class NL80211Attr : public BaseNL80211Attr {
  61  public:
  62   NL80211Attr(int id, T value) {
  63     static_assert(
  64         std::is_integral<T>::value,
  65         "Failed to create NL80211Attr class with non-integral type");
  66     InitHeaderAndResize(id, sizeof(T));
  67     T* storage = reinterpret_cast<T*>(data_.data() + NLA_HDRLEN);
  68     *storage = value;
  69   }
  70   // Caller is responsible for ensuring that |data| is:
  71   //   1) Is at least NLA_HDRLEN long.
  72   //   2) That *data when interpreted as a nlattr is internally consistent.
  73   // (e.g. data.size() == NLA_ALIGN(nlattr.nla_len)
  74   // and nla_len == NLA_HDRLEN + payload size
  75   explicit NL80211Attr(const std::vector<uint8_t>& data) {
  76     data_ = data;
  77   }
  78
  79   ~NL80211Attr() override = default;
  80
  81   bool IsValid() const override {
  82     if (!BaseNL80211Attr::IsValid()) {
  83       return false;
  84     }
  85     // If BaseNL80211Attr::IsValid() == true, at least we have enough valid
  86     // buffer for header.
  87     const nlattr* header = reinterpret_cast<const nlattr*>(data_.data());
  88     // Buffer size = header size +  payload size + padding size
  89     // nla_len  =  header size + payload size
  90     if (NLA_ALIGN(sizeof(T)) + NLA_HDRLEN != data_.size() ||
  91         sizeof(T) + NLA_HDRLEN != header->nla_len ) {
  92       return false;
  93     }
  94     return true;
  95   }
  96
  97   T GetValue() const {
  98     return *reinterpret_cast<const T*>(data_.data() + NLA_HDRLEN);
  99   }
 100 };  // class NL80211Attr for POD-types
 101
 102 template <>
 103 class NL80211Attr<std::vector<uint8_t>> : public BaseNL80211Attr {
 104  public:
 105   NL80211Attr(int id, const std::vector<uint8_t>& raw_buffer);
 106   explicit NL80211Attr(const std::vector<uint8_t>& data);
 107   ~NL80211Attr() override = default;
 108   std::vector<uint8_t> GetValue() const;
 109 }; // class NL80211Attr for raw data
 110
 111 template <>
 112 class NL80211Attr<std::string> : public BaseNL80211Attr {
 113  public:
 114   NL80211Attr(int id, const std::string& str);
 115   // We parse string attribute buffer in the same way kernel does.
 116   // All trailing zeros are trimmed when retrieving a std::string from
 117   // byte array.
 118   explicit NL80211Attr(const std::vector<uint8_t>& data);
 119   ~NL80211Attr() override = default;
 120   std::string GetValue() const;
 121 };  // class NL80211Attr for string
 122
 123 // Force the compiler not to instantiate these templates because
 124 // they will be instantiated in nl80211_attribute.cpp file. This helps
 125 // reduce compile time as well as object file size.
 126 extern template class NL80211Attr<uint8_t>;
 127 extern template class NL80211Attr<uint16_t>;
 128 extern template class NL80211Attr<uint32_t>;
 129 extern template class NL80211Attr<uint64_t>;
 130 extern template class NL80211Attr<std::vector<uint8_t>>;
 131 extern template class NL80211Attr<std::string>;
 132
 133 class NL80211NestedAttr : public BaseNL80211Attr {
 134  public:
 135   explicit NL80211NestedAttr(int id);
 136   explicit NL80211NestedAttr(const std::vector<uint8_t>& data);
 137   ~NL80211NestedAttr() override = default;
 138
 139   void AddAttribute(const BaseNL80211Attr& attribute);
 140   // For NLA_FLAG attribute
 141   void AddFlagAttribute(int attribute_id);
 142   bool HasAttribute(int id) const;
 143
 144   // Access an attribute nested within |this|.
 145   // The result is returned by writing the attribute object to |*attribute|.
 146   // Deeper nested attributes are not included. This means if A is nested within
 147   // |this|, and B is nested within A, this function can't be used to access B.
 148   // The reason is that we may have multiple attributes having the same
 149   // attribute id, nested within different level of |this|.
 150   bool GetAttribute(int id, NL80211NestedAttr* attribute) const;
 151
 152   template <typename T>
 153   bool GetAttributeValue(int id, T* value) const {
 154     std::vector<uint8_t> empty_vec;
 155     // All data in |attribute| created here will be overwritten by
 156     // GetAttribute(). So we use an empty vector to initialize it,
 157     // regardless of the fact that an empty buffer is not qualified
 158     // for creating a valid attribute.
 159     NL80211Attr<T> attribute(empty_vec);
 160     if (!GetAttribute(id, &attribute)) {
 161       return false;
 162     }
 163     *value = attribute.GetValue();
 164     return true;
 165   }
 166
 167   // Some of the nested attribute contains a list of same type sub-attributes.
 168   // This function retrieves a vector of attribute value from a nested
 169   // attribute.
 170   // This is for both correctness and performance reasons:
 171   //
 172   // Correctness reason:
 173   // These sub-attributes have attribute id from '0 to n' or '1 to n'.
 174   // There is no document defining what the start index should be.
 175   // This function ignore all these fake attribute ids.
 176   //
 177   // Performance reson:
 178   // Calling GetAttributeValue() from '0 to n' results a n^2 time complexity.
 179   // This function get a list of attribute values in one pass.
 180   //
 181   // Returns true on success.
 182   template <typename T>
 183   bool GetListOfAttributeValues(std::vector<T>* value) const {
 184     const uint8_t* ptr = data_.data() + NLA_HDRLEN;
 185     const uint8_t* end_ptr = data_.data() + data_.size();
 186     std::vector<T> attr_list;
 187     while (ptr + NLA_HDRLEN <= end_ptr) {
 188       const nlattr* header = reinterpret_cast<const nlattr*>(ptr);
 189       if (ptr + NLA_ALIGN(header->nla_len) > end_ptr) {
 190         LOG(ERROR) << "Failed to get list of attributes: invalid nla_len.";
 191         return false;
 192       }
 193       NL80211Attr<T> attribute(std::vector<uint8_t>(
 194           ptr,
 195           ptr + NLA_ALIGN(header->nla_len)));
 196       if (!attribute.IsValid()) {
 197         return false;
 198       }
 199       attr_list.emplace_back(attribute.GetValue());
 200       ptr += NLA_ALIGN(header->nla_len);
 201     }
 202     *value = std::move(attr_list);
 203     return true;
 204   }
 205
 206   // This is similar to |GetListOfAttributeValues|, but for the cases where all
 207   // the sub-attributes are nested attributes.
 208   bool GetListOfNestedAttributes(std::vector<NL80211NestedAttr>* value) const;
 209
 210   template <typename T>
 211   bool GetAttribute(int id, NL80211Attr<T>* attribute) const {
 212     uint8_t* start = nullptr;
 213     uint8_t* end = nullptr;
 214     if (!BaseNL80211Attr::GetAttributeImpl(data_.data() + NLA_HDRLEN,
 215                                            data_.size() - NLA_HDRLEN,
 216                                            id, &start, &end) ||
 217         start == nullptr ||
 218         end == nullptr) {
 219       return false;
 220     }
 221     *attribute = NL80211Attr<T>(std::vector<uint8_t>(start, end));
 222     if (!attribute->IsValid()) {
 223       return false;
 224     }
 225     return true;
 226   }
 227
 228   void DebugLog() const;
 229
 230 };
 231
 232 }  // namespace wificond
 233 }  // namespace android
 234
 235 #endif  // WIFICOND_NET_NL80211_ATTRIBUTE_H_