network.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2015 Samsung Electronics Co., Ltd All Rights Reserved
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1 as published by the Free Software Foundation.
 *
 *  This 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 a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef LXCPP_NETWORK_HPP
#define LXCPP_NETWORK_HPP

#include "config.hpp"
#include <cargo/fields.hpp>

#include <cstring>
#include <string>
#include <vector>
#include <array>
#include <ostream>

#include <arpa/inet.h>

namespace lxcpp {

std::string toString(const in_addr& addr);
std::string toString(const in6_addr& addr);
void fromString(const std::string& s, in_addr& addr);
void fromString(const std::string& s, in6_addr& addr);

enum class InetAddrType {
    IPV4,
    IPV6
};

class InetAddr {
public:
    InetAddr() : InetAddr("", 0) {}
    InetAddr(const std::string& addr, unsigned prefix, uint32_t flags=0);

    template<typename T>
    T& getAddr() {
        std::uint8_t *v = addr.data();
        return *(reinterpret_cast<T*>(v));
    }
    template<typename T>
    const T& getAddr() const {
        const std::uint8_t *v = addr.data();
        return *(reinterpret_cast<const T*>(v));
    }

    InetAddrType type;
    unsigned prefix;
    uint32_t flags;

    CARGO_REGISTER
    (
        type,
        flags,
        prefix,
        addr
    )

private:
    std::array<std::uint8_t,sizeof(in6_addr)> addr;
};

static inline bool operator==(const in_addr& a, const in_addr& b)
{
    return ::memcmp(&a, &b, sizeof(a)) == 0;
}

static inline bool operator==(const in6_addr& a, const in6_addr& b)
{
    return ::memcmp(&a, &b, sizeof(a)) == 0;
}

static inline bool operator==(const InetAddr& a, const InetAddr& b)
{
    if (a.type == b.type && a.prefix == b.prefix) {
        if (a.type == InetAddrType::IPV6)
            return a.getAddr<in6_addr>() == b.getAddr<in6_addr>();
        else
            return a.getAddr<in_addr>() == b.getAddr<in_addr>();
    }
    return false;
}

std::string toString(const InetAddr& a);

enum class RoutingTable {
    UNSPEC, // also means 'any'
    COMPAT,
    DEFAULT,
    MAIN,
    LOCAL,
    USER,
};

inline std::string toString(const RoutingTable rt)
{
    switch (rt) {
    case RoutingTable::UNSPEC:
        return "unspec";
    case RoutingTable::COMPAT:
        return "compat";
    case RoutingTable::DEFAULT:
        return "default";
    case RoutingTable::MAIN:
        return "main";
    case RoutingTable::LOCAL:
        return "local";
    default:
        return "user";
    }
}

struct Route {
    InetAddr dst;
    InetAddr src;
    unsigned metric;
    std::string ifname;
    RoutingTable table;
};

enum class AttrName {
    MAC,
    FLAGS,
    CHANGE,
    TYPE,
    MTU,
    LINK,
    TXQLEN,
};

inline std::ostream& operator<<(std::ostream& os, const AttrName& a) {
    switch (a) {
        case AttrName::MAC: os << "mac"; break;
        case AttrName::FLAGS: os << "flags"; break;
        case AttrName::CHANGE: os << "change"; break;
        case AttrName::TYPE: os << "type"; break;
        case AttrName::MTU: os << "mtu"; break;
        case AttrName::LINK: os << "link"; break;
        case AttrName::TXQLEN: os << "txq"; break;
    }
    return os;
}

struct Attr {
    AttrName name;
    std::string value;
};

typedef std::vector<Attr> Attrs;

enum class InterfaceType : int {
    VETH,
    BRIDGE,
    MACVLAN
};

enum class MacVLanMode {
    PRIVATE,
    VEPA,
    BRIDGE,
    PASSTHRU
};

enum class NetStatus {
    DOWN,
    UP
};

std::string toString(const InetAddr& a);

class NetworkInterface {
    //TODO: remove pid from NetworkInterface (and from netlink)
public:
    NetworkInterface(const std::string& ifname, pid_t pid = 0) :
        mIfname(ifname),
        mContainerPid(pid)
    {
    }

    const std::string& getName() const { return mIfname; }

    bool exists() const noexcept;

    NetStatus status() const;

    void create(InterfaceType type, const std::string& peerif = "", MacVLanMode mode = MacVLanMode::PRIVATE);

    void destroy();

    void moveToContainer(pid_t pid);

    void renameFrom(const std::string& oldif);

    void addToBridge(const std::string& bridge);

    void delFromBridge();

    void setAttrs(const Attrs& attrs);
    Attrs getAttrs() const;

    void addInetAddr(const InetAddr& addr);

    void delInetAddr(const InetAddr& addr);

    std::vector<InetAddr> getInetAddressList() const;

    void addRoute(const Route& route, const RoutingTable rt = RoutingTable::MAIN);

    void delRoute(const Route& route, const RoutingTable rt = RoutingTable::MAIN);

    std::vector<Route> getRoutes(const RoutingTable rt = RoutingTable::MAIN) const;

    void up();

    void down();

    void setMACAddress(const std::string& macaddr);

    void setMTU(int mtu);

    void setTxLength(int txlen);

    static std::vector<std::string> getInterfaces(pid_t initpid);

    static std::vector<Route> getRoutes(pid_t initpid, const RoutingTable rt = RoutingTable::MAIN);

private:
    void createVeth(const std::string& peerif);
    void createBridge();
    void createMacVLan(const std::string& masterif, MacVLanMode mode);

    void modifyRoute(int cmd, const InetAddr& src, const InetAddr& dst);

    const std::string mIfname; 
    pid_t mContainerPid;       
};

} // namespace lxcpp

#endif // LXCPP_NETWORK_HPP