ibrcommon/ibrcommon/net/NetInterface.cpp

Go to the documentation of this file.

/*
 * File:   NetInterface.cpp
 * Author: morgenro
 *
 * Created on 12. November 2009, 14:57
 */

#include "ibrcommon/config.h"
#include "ibrcommon/net/NetInterface.h"
#include "ibrcommon/thread/MutexLock.h"
#include "ibrcommon/Exceptions.h"

#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#include <stdlib.h>
#include <net/if.h>

#ifdef HAVE_LIBNL
#include <netlink/route/link.h>
#include <netlink/route/addr.h>
#include <netlink/genl/genl.h>
#include <netlink/genl/ctrl.h>
#endif

#include <errno.h>

#ifdef HAVE_LOWPAN_SUPPORT
extern "C" {
#include "ibrcommon/net/ieee802154.h"
#include "ibrcommon/net/nl802154.h"
extern struct nla_policy ieee802154_policy[IEEE802154_ATTR_MAX + 1];
};
#endif

#include <unistd.h>

using namespace std;

namespace ibrcommon
{
#ifdef HAVE_LIBNL
void add_addr_to_list(struct nl_object *obj, void *data)
{
        char buf[INET6_ADDRSTRLEN + 1];
        std::list<NetAddress> *list = static_cast<std::list<NetAddress>*>(data);

    struct nl_addr *naddr =
        rtnl_addr_get_local((struct rtnl_addr *) obj);
    int family = nl_addr_get_family(naddr);

    if (family == AF_INET6)
    {
        struct in6_addr *tmpaddr = (struct in6_addr *) nl_addr_get_binary_addr(naddr);

        if (inet_ntop (AF_INET6, tmpaddr, buf, sizeof (buf)))
        {
                list->push_back( NetAddress(NetAddress::NETADDR_IP6, buf, nl_addr_get_prefixlen(naddr)) );
        }
    }
    else if (family == AF_INET)
    {
        struct in_addr *tmpaddr = (struct in_addr *) nl_addr_get_binary_addr(naddr);

        if (inet_ntop (AF_INET, tmpaddr, buf, sizeof (buf)))
        {
                list->push_back( NetAddress(NetAddress::NETADDR_IP, buf, nl_addr_get_prefixlen(naddr)) );
        }
    }
}

void add_broadcast_addr_to_list(struct nl_object *obj, void *data)
{
        char buf[INET6_ADDRSTRLEN + 1];
        std::list<NetAddress> *list = static_cast<std::list<NetAddress>*>(data);

        struct nl_addr *naddr = rtnl_addr_get_local((struct rtnl_addr *) obj);
        int family = nl_addr_get_family(naddr);

        struct nl_addr *baddr = rtnl_addr_get_broadcast((struct rtnl_addr *) obj);

        if (baddr)
        {
                nl_addr2str( baddr, buf, sizeof( buf ) );

                if (family == AF_INET6)
                {
                        list->push_back( NetAddress(NetAddress::NETADDR_IP6, buf, nl_addr_get_prefixlen(baddr)) );
                }
                else if (family == AF_INET)
                {
                        list->push_back( NetAddress(NetAddress::NETADDR_IP, buf, nl_addr_get_prefixlen(baddr)) );
                }
        }
}
#endif

        // static initialization
        NetInterface::NetLinkWrapper NetInterface::_nlwrapper;

        NetInterface::NetLinkWrapper::NetLinkWrapper()
        {
                _handle = nl_handle_alloc();
                nl_connect(_handle, NETLINK_ROUTE);

                _link_cache = rtnl_link_alloc_cache(_handle);
                _addr_cache = rtnl_addr_alloc_cache(_handle);
        }

        NetInterface::NetLinkWrapper::~NetLinkWrapper()
        {
                nl_cache_free(_addr_cache);
                nl_cache_free(_link_cache);
                nl_handle_destroy(_handle);
        }

        const std::list<NetAddress> NetInterface::NetLinkWrapper::getAddressList(const std::string interface) const
        {
                ibrcommon::MutexLock l(_mutex);
                std::list<NetAddress> addresses;

                struct rtnl_addr *filter = rtnl_addr_alloc();
                rtnl_addr_set_ifindex(filter, rtnl_link_name2i(_link_cache, interface.c_str()));

                rtnl_addr_set_family(filter, AF_INET6);
                nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
                                                                add_addr_to_list, &addresses);

                rtnl_addr_set_family(filter, AF_INET);
                nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
                                                                add_addr_to_list, &addresses);

                rtnl_addr_put(filter);

                return addresses;
        }

        const std::list<NetAddress> NetInterface::NetLinkWrapper::getBroadcastList(const std::string interface) const
        {
                ibrcommon::MutexLock l(_mutex);
                std::list<NetAddress> addresses;

                struct rtnl_addr *filter = rtnl_addr_alloc();
                rtnl_addr_set_ifindex(filter, rtnl_link_name2i(_link_cache, interface.c_str()));

                rtnl_addr_set_family(filter, AF_INET6);
                nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
                                                                add_broadcast_addr_to_list, &addresses);

                rtnl_addr_set_family(filter, AF_INET);
                nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
                                                                add_broadcast_addr_to_list, &addresses);

                rtnl_addr_put(filter);

                return addresses;
        }

        NetInterface::NetInterface(std::string interface)
        : _interface(interface)
        {
        }

        NetInterface::~NetInterface()
        {
        }

        bool NetInterface::operator<(const NetInterface &other) const
        {
                if (_interface < other._interface) return true;
                return false;
        }

        bool NetInterface::operator==(const NetInterface &other) const
        {
                if (_interface == other._interface) return true;
                return false;
        }

        const std::string NetInterface::toString() const
        {
                return _interface;
        }

        const std::list<NetAddress> NetInterface::getAddressList() const
        {
                return _nlwrapper.getAddressList(_interface);
        }

        const NetAddress NetInterface::getAddress(const NetAddress::ADDR_TYPE type) const
        {
                std::list<NetAddress> list = getAddressList();

                for (std::list<NetAddress>::const_iterator iter = list.begin(); iter != list.end(); iter++)
                {
                        if (iter->type == type)
                        {
                                return (*iter);
                        }
                }

                throw ibrcommon::Exception("no address found");
        }

        void NetInterface::getAddress(struct in_addr *ret) const
        {
                NetAddress addr = getAddress(NetAddress::NETADDR_IP);
                inet_aton(addr.toString().c_str(), ret);
        }

        const std::string NetInterface::getAddress() const
        {
                return getAddress(NetAddress::NETADDR_IP).toString();
        }

        /* The Linux MAC802152 stack speaks netlink to userspace. Use it to get
         * the current address and PAN ID */
        void NetInterface::getAddress(struct ieee802154_addr *ret) const
        {
#ifdef HAVE_LOWPAN_SUPPORT
                struct nl_handle *nl = nl_handle_alloc();
                unsigned char *buf = NULL;
                struct sockaddr_nl nla;
                struct nlattr *attrs[IEEE802154_ATTR_MAX+1];
                struct genlmsghdr *ghdr;
                struct nlmsghdr *nlh;
                struct nl_msg *msg;
                int family;

                if (!nl)
                        return;

                genl_connect(nl);

                /* Build and send message */
                msg = nlmsg_alloc();
                family = genl_ctrl_resolve(nl, "802.15.4 MAC");
                genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, family, 0, NLM_F_ECHO, IEEE802154_LIST_IFACE, 1);
                nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, _interface.c_str());
                nl_send_auto_complete(nl, msg);
                nlmsg_free(msg);

                /* Receive and parse answer */
                nl_recv(nl, &nla, &buf, NULL);
                nlh = (struct nlmsghdr*)buf;
                genlmsg_parse(nlh, 0, attrs, IEEE802154_ATTR_MAX, ieee802154_policy);
                ghdr = (genlmsghdr*)nlmsg_data(nlh);
                if (!attrs[IEEE802154_ATTR_SHORT_ADDR] || !attrs[IEEE802154_ATTR_SHORT_ADDR])
                        return;

                // We only handle short addresses right now
                ret->addr_type = IEEE802154_ADDR_SHORT;
                ret->pan_id = nla_get_u16(attrs[IEEE802154_ATTR_PAN_ID]);
                ret->short_addr = nla_get_u16(attrs[IEEE802154_ATTR_SHORT_ADDR]);

                free(buf);
                nl_close(nl);
#endif
        }

        const NetAddress NetInterface::getBroadcast(const NetAddress::ADDR_TYPE type) const
        {
                std::list<NetAddress> list = getBroadcastList();

                for (std::list<NetAddress>::const_iterator iter = list.begin(); iter != list.end(); iter++)
                {
                        if (iter->type == type)
                        {
                                return (*iter);
                        }
                }

                throw ibrcommon::Exception("no address found");
        }

        const std::list<NetAddress> NetInterface::getBroadcastList() const
        {
                return _nlwrapper.getBroadcastList(_interface);
        }
}