netlink-message.hpp

Go to the documentation of this file.

/*
 *  Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
 *
 *  Contact: Mateusz Malicki <m.malicki2@samsung.com>
 *
 *  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 COMMON_NETLINK_NETLINK_MESSAGE_HPP
#define COMMON_NETLINK_NETLINK_MESSAGE_HPP

#include <limits>
#include <memory>
#include <string>
#include <vector>
#include <stack>
#include <type_traits>
#include <cstdlib>
#include <sys/socket.h>
#include <linux/netlink.h>

//FIXME remove from namespace vasum
namespace vasum {
namespace netlink {

class NetlinkResponse;
class NetlinkMessage;

class NetlinkMessage {
public:
    NetlinkMessage(std::uint16_t type, std::uint16_t flags);

    NetlinkMessage& beginNested(int ifla);

    NetlinkMessage& endNested();

    /*Add sample attribute */
    NetlinkMessage& put(int ifla, const std::string& value);
    template<class T>
    NetlinkMessage& put(int ifla, const T& value);

    template<class T>
    NetlinkMessage& put(const T& value);

    friend NetlinkResponse send(const NetlinkMessage& msg, int pid);
private:
    std::vector<char> mNlmsg;
    std::stack<int> mNested;

    NetlinkMessage& put(int ifla, const void* data, int len);
    NetlinkMessage& put(const void* data, int len);
    nlmsghdr& hdr();
    const nlmsghdr& hdr() const;
    void setMinCapacity(unsigned int size);
};

class NetlinkResponse {
public:
    bool hasMessage() const;

    void fetchNextMessage();

    int getMessageType() const;

    bool hasAttribute() const;

    bool isNestedAttribute() const;

    void skipAttribute();

    NetlinkResponse& openNested(int ifla);

    NetlinkResponse& closeNested();


    NetlinkResponse& fetch(int ifla, std::string& value, unsigned maxLen = std::numeric_limits<unsigned>::max());
    template<class T>
    NetlinkResponse& fetch(int ifla, T& value);

    int getAttributeType() const;

    int getAttributeLength() const;

    template<class T>
    NetlinkResponse& fetch(T& value);

    template<class T>
    NetlinkResponse& skip();

    friend NetlinkResponse send(const NetlinkMessage& msg, int pid);
private:
    NetlinkResponse(std::unique_ptr<std::vector<char>>&& message);

    std::unique_ptr<std::vector<char>> mNlmsg;
    std::stack<int> mNested;
    nlmsghdr* mNlmsgHdr;
    int mPosition;

    const char* get(int ifla, int iflasize) const;
    const char* get(int size = 0) const;
    NetlinkResponse& fetch(int ifla, char* data, int len);
    NetlinkResponse& fetch(char* data, int len);
    NetlinkResponse& seek(int len);
    int size() const;
    int getHdrPosition() const;
};

NetlinkResponse send(const NetlinkMessage& msg);

template<class T>
NetlinkMessage& NetlinkMessage::put(int ifla, const T& value)
{
    static_assert(std::is_pod<T>::value, "Require trivial and standard-layout");
    return put(ifla, &value, sizeof(value));
}

template<class T>
NetlinkMessage& NetlinkMessage::put(const T& value)
{
    static_assert(std::is_pod<T>::value, "Require trivial and standard-layout structure");
    return put(&value, sizeof(value));
}

template<class T>
NetlinkResponse& NetlinkResponse::fetch(int ifla, T& value)
{
    static_assert(std::is_pod<T>::value, "Require trivial and standard-layout");
    return fetch(ifla, reinterpret_cast<char*>(&value), sizeof(value));
}

template<class T>
NetlinkResponse& NetlinkResponse::fetch(T& value)
{
    static_assert(std::is_pod<T>::value, "Require trivial and standard-layout structure");
    return fetch(reinterpret_cast<char*>(&value), sizeof(value));
}

template<class T>
NetlinkResponse& NetlinkResponse::skip()
{
    static_assert(std::is_pod<T>::value, "Require trivial and standard-layout structure");
    return seek(sizeof(T));
}

} // namespace netlink
} // namespace vasum

#endif // COMMON_NETLINK_NETLINK_MESSAGE_HPP