You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
258 lines
8.2 KiB
258 lines
8.2 KiB
/*
|
|
* 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/net/nl80211_packet.h"
|
|
|
|
#include <android-base/logging.h>
|
|
|
|
using std::vector;
|
|
|
|
namespace android {
|
|
namespace wificond {
|
|
|
|
NL80211Packet::NL80211Packet(const vector<uint8_t>& data)
|
|
: data_(data) {
|
|
data_ = data;
|
|
}
|
|
|
|
NL80211Packet::NL80211Packet(const NL80211Packet& packet) {
|
|
data_ = packet.data_;
|
|
LOG(WARNING) << "Copy constructor is only used for unit tests";
|
|
}
|
|
|
|
NL80211Packet::NL80211Packet(uint16_t type,
|
|
uint8_t command,
|
|
uint32_t sequence,
|
|
uint32_t pid) {
|
|
// Initialize the netlink header and generic netlink header.
|
|
// NLMSG_HDRLEN and GENL_HDRLEN already include the padding size.
|
|
data_.resize(NLMSG_HDRLEN + GENL_HDRLEN, 0);
|
|
// Initialize length field.
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
nl_header->nlmsg_len = data_.size();
|
|
// Add NLM_F_REQUEST flag.
|
|
nl_header->nlmsg_flags = nl_header->nlmsg_flags | NLM_F_REQUEST;
|
|
nl_header->nlmsg_type = type;
|
|
nl_header->nlmsg_seq = sequence;
|
|
nl_header->nlmsg_pid = pid;
|
|
|
|
genlmsghdr* genl_header =
|
|
reinterpret_cast<genlmsghdr*>(data_.data() + NLMSG_HDRLEN);
|
|
genl_header->version = 1;
|
|
genl_header->cmd = command;
|
|
// genl_header->reserved is aready 0.
|
|
}
|
|
|
|
bool NL80211Packet::IsValid() const {
|
|
// Verify the size of packet.
|
|
if (data_.size() < NLMSG_HDRLEN) {
|
|
LOG(ERROR) << "Cannot retrieve netlink header.";
|
|
return false;
|
|
}
|
|
|
|
const nlmsghdr* nl_header = reinterpret_cast<const nlmsghdr*>(data_.data());
|
|
|
|
// If type < NLMSG_MIN_TYPE, this should be a reserved control message,
|
|
// which doesn't carry a generic netlink header.
|
|
if (GetMessageType() >= NLMSG_MIN_TYPE) {
|
|
if (data_.size() < NLMSG_HDRLEN + GENL_HDRLEN ||
|
|
nl_header->nlmsg_len < NLMSG_HDRLEN + GENL_HDRLEN) {
|
|
LOG(ERROR) << "Cannot retrieve generic netlink header.";
|
|
return false;
|
|
}
|
|
}
|
|
// If it is an ERROR message, it should be long enough to carry an extra error
|
|
// code field.
|
|
// Kernel uses int for this field.
|
|
if (GetMessageType() == NLMSG_ERROR) {
|
|
if (data_.size() < NLMSG_HDRLEN + sizeof(int) ||
|
|
nl_header->nlmsg_len < NLMSG_HDRLEN + sizeof(int)) {
|
|
LOG(ERROR) << "Broken error message.";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Verify the netlink header.
|
|
if (data_.size() < nl_header->nlmsg_len ||
|
|
nl_header->nlmsg_len < sizeof(nlmsghdr)) {
|
|
LOG(ERROR) << "Discarding incomplete / invalid message.";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool NL80211Packet::IsDump() const {
|
|
return GetFlags() & NLM_F_DUMP;
|
|
}
|
|
|
|
bool NL80211Packet::IsMulti() const {
|
|
return GetFlags() & NLM_F_MULTI;
|
|
}
|
|
|
|
uint8_t NL80211Packet::GetCommand() const {
|
|
const genlmsghdr* genl_header = reinterpret_cast<const genlmsghdr*>(
|
|
data_.data() + NLMSG_HDRLEN);
|
|
return genl_header->cmd;
|
|
}
|
|
|
|
uint16_t NL80211Packet::GetFlags() const {
|
|
const nlmsghdr* nl_header = reinterpret_cast<const nlmsghdr*>(data_.data());
|
|
return nl_header->nlmsg_flags;
|
|
}
|
|
|
|
uint16_t NL80211Packet::GetMessageType() const {
|
|
const nlmsghdr* nl_header = reinterpret_cast<const nlmsghdr*>(data_.data());
|
|
return nl_header->nlmsg_type;
|
|
}
|
|
|
|
uint32_t NL80211Packet::GetMessageSequence() const {
|
|
const nlmsghdr* nl_header = reinterpret_cast<const nlmsghdr*>(data_.data());
|
|
return nl_header->nlmsg_seq;
|
|
}
|
|
|
|
uint32_t NL80211Packet::GetPortId() const {
|
|
const nlmsghdr* nl_header = reinterpret_cast<const nlmsghdr*>(data_.data());
|
|
return nl_header->nlmsg_pid;
|
|
}
|
|
|
|
int NL80211Packet::GetErrorCode() const {
|
|
return -*reinterpret_cast<const int*>(data_.data() + NLMSG_HDRLEN);
|
|
}
|
|
|
|
const vector<uint8_t>& NL80211Packet::GetConstData() const {
|
|
return data_;
|
|
}
|
|
|
|
void NL80211Packet::SetCommand(uint8_t command) {
|
|
genlmsghdr* genl_header = reinterpret_cast<genlmsghdr*>(
|
|
data_.data() + NLMSG_HDRLEN);
|
|
genl_header->cmd = command;
|
|
}
|
|
|
|
void NL80211Packet::AddFlag(uint16_t flag) {
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
nl_header->nlmsg_flags |= flag;
|
|
}
|
|
|
|
void NL80211Packet::SetFlags(uint16_t flags) {
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
nl_header->nlmsg_flags = flags;
|
|
}
|
|
|
|
void NL80211Packet::SetMessageType(uint16_t message_type) {
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
nl_header->nlmsg_type = message_type;
|
|
}
|
|
|
|
void NL80211Packet::SetMessageSequence(uint32_t message_sequence) {
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
nl_header->nlmsg_seq = message_sequence;
|
|
}
|
|
|
|
void NL80211Packet::SetPortId(uint32_t pid) {
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
nl_header->nlmsg_pid = pid;
|
|
}
|
|
|
|
void NL80211Packet::AddAttribute(const BaseNL80211Attr& attribute) {
|
|
const vector<uint8_t>& append_data = attribute.GetConstData();
|
|
// Append the data of |attribute| to |this|.
|
|
data_.insert(data_.end(), append_data.begin(), append_data.end());
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
// We don't need to worry about padding for a nl80211 packet.
|
|
// Because as long as all sub attributes have padding, the payload is aligned.
|
|
nl_header->nlmsg_len += append_data.size();
|
|
}
|
|
|
|
void NL80211Packet::AddFlagAttribute(int attribute_id) {
|
|
// We only need to append a header for flag attribute.
|
|
// Make space for the new attribute.
|
|
data_.resize(data_.size() + NLA_HDRLEN, 0);
|
|
nlattr* flag_header =
|
|
reinterpret_cast<nlattr*>(data_.data() + data_.size() - NLA_HDRLEN);
|
|
flag_header->nla_type = attribute_id;
|
|
flag_header->nla_len = NLA_HDRLEN;
|
|
nlmsghdr* nl_header = reinterpret_cast<nlmsghdr*>(data_.data());
|
|
nl_header->nlmsg_len += NLA_HDRLEN;
|
|
}
|
|
|
|
bool NL80211Packet::HasAttribute(int id) const {
|
|
return BaseNL80211Attr::GetAttributeImpl(
|
|
data_.data() + NLMSG_HDRLEN + GENL_HDRLEN,
|
|
data_.size() - NLMSG_HDRLEN - GENL_HDRLEN,
|
|
id, nullptr, nullptr);
|
|
}
|
|
|
|
bool NL80211Packet::GetAttribute(int id,
|
|
NL80211NestedAttr* attribute) const {
|
|
uint8_t* start = nullptr;
|
|
uint8_t* end = nullptr;
|
|
if (!BaseNL80211Attr::GetAttributeImpl(
|
|
data_.data() + NLMSG_HDRLEN + GENL_HDRLEN,
|
|
data_.size() - NLMSG_HDRLEN - GENL_HDRLEN,
|
|
id, &start, &end) ||
|
|
start == nullptr ||
|
|
end == nullptr) {
|
|
return false;
|
|
}
|
|
*attribute = NL80211NestedAttr(vector<uint8_t>(start, end));
|
|
if (!attribute->IsValid()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool NL80211Packet::GetAllAttributes(
|
|
vector<BaseNL80211Attr>* attributes) const {
|
|
const uint8_t* ptr = data_.data() + NLMSG_HDRLEN + GENL_HDRLEN;
|
|
const uint8_t* end_ptr = data_.data() + data_.size();
|
|
while (ptr + NLA_HDRLEN <= end_ptr) {
|
|
auto header = reinterpret_cast<const nlattr*>(ptr);
|
|
if (ptr + NLA_ALIGN(header->nla_len) > end_ptr ||
|
|
header->nla_len == 0) {
|
|
LOG(ERROR) << "broken nl80211 atrribute.";
|
|
return false;
|
|
}
|
|
attributes->emplace_back(
|
|
header->nla_type,
|
|
vector<uint8_t>(ptr + NLA_HDRLEN, ptr + header->nla_len));
|
|
ptr += NLA_ALIGN(header->nla_len);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void NL80211Packet::DebugLog() const {
|
|
const uint8_t* ptr = data_.data() + NLMSG_HDRLEN + GENL_HDRLEN;
|
|
const uint8_t* end_ptr = data_.data() + data_.size();
|
|
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) << "broken nl80211 atrribute.";
|
|
return;
|
|
}
|
|
LOG(INFO) << "Have attribute with nla_type=" << header->nla_type
|
|
<< " and nla_len=" << header->nla_len;
|
|
if (header->nla_len == 0) {
|
|
LOG(ERROR) << "0 is a bad nla_len";
|
|
return;
|
|
}
|
|
ptr += NLA_ALIGN(header->nla_len);
|
|
}
|
|
}
|
|
|
|
} // namespace wificond
|
|
} // namespace android
|