blob: 3908d4e676b975306388929999aa6284d61e25cb [file] [log] [blame]
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2013-2018 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
* ndn-cxx library is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later version.
*
* ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
* PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received copies of the GNU General Public License and GNU Lesser
* General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
* <http://www.gnu.org/licenses/>.
*
* See AUTHORS.md for complete list of ndn-cxx authors and contributors.
*
* @author Davide Pesavento <davide.pesavento@lip6.fr>
*/
#ifndef NDN_NET_NETLINK_MESSAGE_HPP
#define NDN_NET_NETLINK_MESSAGE_HPP
#include "../../common.hpp"
#include "../ethernet.hpp"
#ifndef NDN_CXX_HAVE_RTNETLINK
#error "This file should not be included ..."
#endif
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <string.h>
#include <cstring>
#include <map>
#include <boost/asio/ip/address.hpp>
namespace ndn {
namespace net {
template<typename T>
constexpr size_t
getAttributeLength(const T* attr);
template<>
constexpr size_t
getAttributeLength(const nlattr* attr)
{
return attr->nla_len;
}
template<>
constexpr size_t
getAttributeLength(const rtattr* attr)
{
return attr->rta_len;
}
template<typename T>
constexpr size_t
getAttributeLengthAligned(const T* attr);
template<>
constexpr size_t
getAttributeLengthAligned(const nlattr* attr)
{
return NLA_ALIGN(attr->nla_len);
}
template<>
constexpr size_t
getAttributeLengthAligned(const rtattr* attr)
{
return RTA_ALIGN(attr->rta_len);
}
template<typename T>
constexpr uint16_t
getAttributeType(const T* attr);
template<>
constexpr uint16_t
getAttributeType(const nlattr* attr)
{
return attr->nla_type & NLA_TYPE_MASK;
}
template<>
constexpr uint16_t
getAttributeType(const rtattr* attr)
{
return attr->rta_type;
}
template<typename T>
const uint8_t*
getAttributeValue(const T* attr);
template<>
inline const uint8_t*
getAttributeValue(const nlattr* attr)
{
return reinterpret_cast<const uint8_t*>(attr) + NLA_HDRLEN;
}
template<>
inline const uint8_t*
getAttributeValue(const rtattr* attr)
{
return reinterpret_cast<const uint8_t*>(RTA_DATA(const_cast<rtattr*>(attr)));
}
template<typename T>
constexpr size_t
getAttributeValueLength(const T* attr);
template<>
constexpr size_t
getAttributeValueLength(const nlattr* attr)
{
return attr->nla_len - NLA_HDRLEN;
}
template<>
constexpr size_t
getAttributeValueLength(const rtattr* attr)
{
return RTA_PAYLOAD(attr);
}
template<typename T>
class NetlinkMessageAttributes;
class NetlinkMessage
{
public:
explicit
NetlinkMessage(const uint8_t* buf, size_t buflen) noexcept
: m_msg(reinterpret_cast<const nlmsghdr*>(buf))
, m_length(buflen)
{
BOOST_ASSERT(buf != nullptr);
}
const nlmsghdr&
operator*() const noexcept
{
return *m_msg;
}
const nlmsghdr*
operator->() const noexcept
{
return m_msg;
}
bool
isValid() const noexcept
{
return NLMSG_OK(m_msg, m_length);
}
NetlinkMessage
getNext() const noexcept
{
BOOST_ASSERT(isValid());
// mimic NLMSG_NEXT
auto thisLen = NLMSG_ALIGN(m_msg->nlmsg_len);
return NetlinkMessage{reinterpret_cast<const uint8_t*>(m_msg) + thisLen, m_length - thisLen};
}
template<typename T>
const T*
getPayload() const noexcept
{
BOOST_ASSERT(isValid());
if (m_msg->nlmsg_len < NLMSG_LENGTH(sizeof(T)))
return nullptr;
return reinterpret_cast<const T*>(NLMSG_DATA(const_cast<nlmsghdr*>(m_msg)));
}
template<typename AttributeT, typename PayloadT>
NetlinkMessageAttributes<AttributeT>
getAttributes(const PayloadT* p) const noexcept
{
BOOST_ASSERT(isValid());
auto begin = reinterpret_cast<const uint8_t*>(p) + NLMSG_ALIGN(sizeof(PayloadT));
auto length = NLMSG_PAYLOAD(m_msg, sizeof(PayloadT));
return NetlinkMessageAttributes<AttributeT>{reinterpret_cast<const AttributeT*>(begin), length};
}
private:
const nlmsghdr* m_msg;
size_t m_length;
};
template<typename T>
class NetlinkMessageAttributes
{
// empty type used to implement tag dispatching in getAttributeByType()
template<typename U>
struct AttrValueTypeTag {};
public:
explicit
NetlinkMessageAttributes(const T* begin, size_t length) noexcept
{
for (; isAttrValid(begin, length); begin = getNextAttr(begin, length)) {
m_attrs[getAttributeType(begin)] = begin;
}
}
size_t
size() const noexcept
{
return m_attrs.size();
}
template<typename U>
optional<U>
getAttributeByType(uint16_t attrType) const
{
auto it = m_attrs.find(attrType);
if (it == m_attrs.end())
return nullopt;
return convertAttrValue(getAttributeValue(it->second),
getAttributeValueLength(it->second),
AttrValueTypeTag<U>{});
}
private:
static bool
isAttrValid(const T* attr, size_t nBytesRemaining) noexcept
{
return attr != nullptr &&
nBytesRemaining >= sizeof(T) &&
getAttributeLength(attr) >= sizeof(T) &&
getAttributeLength(attr) <= nBytesRemaining;
}
static const T*
getNextAttr(const T* attr, size_t& nBytesRemaining) noexcept
{
auto len = getAttributeLengthAligned(attr);
if (len > nBytesRemaining) // prevent integer underflow
return nullptr;
nBytesRemaining -= len;
return reinterpret_cast<const T*>(reinterpret_cast<const uint8_t*>(attr) + len);
}
template<typename Integral>
static std::enable_if_t<std::is_integral<Integral>::value, optional<Integral>>
convertAttrValue(const uint8_t* val, size_t len, AttrValueTypeTag<Integral>)
{
if (len < sizeof(Integral))
return nullopt;
Integral i;
std::memcpy(&i, val, sizeof(Integral));
return i;
}
static optional<std::string>
convertAttrValue(const uint8_t* val, size_t len, AttrValueTypeTag<std::string>)
{
auto str = reinterpret_cast<const char*>(val);
if (::strnlen(str, len) < len)
return std::string(str);
else
return nullopt;
}
static optional<ethernet::Address>
convertAttrValue(const uint8_t* val, size_t len, AttrValueTypeTag<ethernet::Address>)
{
if (len < ethernet::ADDR_LEN)
return nullopt;
return ethernet::Address(val);
}
template<typename IpAddress>
static std::enable_if_t<std::is_same<IpAddress, boost::asio::ip::address_v4>::value ||
std::is_same<IpAddress, boost::asio::ip::address_v6>::value, optional<IpAddress>>
convertAttrValue(const uint8_t* val, size_t len, AttrValueTypeTag<IpAddress>)
{
typename IpAddress::bytes_type bytes;
if (len < bytes.size())
return nullopt;
std::copy_n(val, bytes.size(), bytes.begin());
return IpAddress(bytes);
}
private:
std::map<uint16_t, const T*> m_attrs;
};
} // namespace net
} // namespace ndn
#endif // NDN_NET_NETLINK_MESSAGE_HPP