ibrcommon/ibrcommon/net/NetLinkManager.cpp

Go to the documentation of this file.

/*
 * NetLinkManager.cpp
 *
 *  Created on: 21.12.2010
 *      Author: morgenro
 */

#include "ibrcommon/net/NetLinkManager.h"
#include "ibrcommon/thread/MutexLock.h"
#include "ibrcommon/Logger.h"

#include <netlink/socket.h>
#include <netlink/route/rtnl.h>
#include <netlink/route/link.h>
#include <netlink/route/addr.h>
#include <netlink/genl/genl.h>
#include <netlink/genl/ctrl.h>

#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/tcp.h>
#include <sys/un.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <arpa/inet.h>

#include <iostream>
#include <sstream>

namespace ibrcommon
{
        NetLinkManager::NetLinkManager()
         : _initialized(false), _sock(NULL)
        {
                ibrcommon::MutexLock l(_call_mutex);

                _handle = nl_handle_alloc();
                nl_connect(_handle, NETLINK_ROUTE);

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

                _initialized = true;

                // create a new socket for the netlink interface
                _sock = new ibrcommon::vsocket();
        }

        NetLinkManager::~NetLinkManager()
        {
                stop();
                join();

                // destroy the socket for the netlink interface
                _sock = new ibrcommon::vsocket();

                nl_close(_handle);
                nl_cache_free(_addr_cache);
                nl_cache_free(_link_cache);
                nl_handle_destroy(_handle);
        }

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

                struct nl_addr *naddr = rtnl_addr_get_local((struct rtnl_addr *) obj);
                int ifindex = 0;
                int scope = rtnl_addr_get_scope((struct rtnl_addr *) obj);

                if (scope == rtnl_str2scope("link"))
                        ifindex = rtnl_addr_get_ifindex((struct rtnl_addr *) obj);

                if (naddr)
                {
                        int family = nl_addr_get_family(naddr);
                        nl_addr2str( naddr, buf, sizeof( buf ) );
                        vaddress vaddr(vaddress::Family(family), std::string(buf), ifindex, false);
                        list->push_back( vaddr );
                }

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

                if (baddr)
                {
                        int family = nl_addr_get_family(baddr);
                        nl_addr2str( baddr, buf, sizeof( buf ) );
                        vaddress vaddr(vaddress::Family(family), std::string(buf), ifindex, true);
                        list->push_back( vaddr );
                }
        }

        bool NetLinkManager::__cancellation()
        {
                ibrcommon::MutexLock l(_call_mutex);
                _initialized = false;
                ibrcommon::interrupt(*_sock, *this);

                return true;
        }

        void NetLinkManager::run()
        {
                Thread::enable_interruption();

                struct nl_handle *handle = nl_handle_alloc();
                nl_connect(handle, NETLINK_ROUTE);

                // init route messages
                nl_socket_add_membership(handle, RTMGRP_IPV6_IFADDR);
                nl_socket_add_membership(handle, RTMGRP_IPV4_IFADDR);
                nl_socket_add_membership(handle, RTMGRP_LINK);

                // add netlink fd to vsocket
                _sock->add(nl_socket_get_fd(handle));

                try {
                        while (_initialized)
                        {
                                std::list<int> fds;
                                ibrcommon::select(*_sock, fds, NULL);
                                int fd = fds.front();

                                std::map<int, std::string> attr = read_nlmsg(fd);
                                std::string ifname(attr[IFLA_IFNAME]);
                                vinterface iface(ifname.substr(0, ifname.length() - 1));

                                // search for event subscriptions
                                ibrcommon::MutexLock l(_listener_mutex);
                                const std::set<LinkManager::EventCallback* > &ss = _listener[iface];

                                for (std::set<LinkManager::EventCallback* >::iterator iter = ss.begin(); iter != ss.end(); iter++)
                                {
                                        IBRCOMMON_LOGGER_DEBUG(10) << "one socket has subscribed action on interface: " << iface.toString() << IBRCOMMON_LOGGER_ENDL;
                                }
                        }
                } catch (const vsocket_exception&) {
                        // stopped / interrupted
                }

                nl_close(handle);
                nl_handle_destroy(handle);
        }

        const std::list<vaddress> NetLinkManager::getAddressList(const vinterface &interface, const vaddress::Family f)
        {
                ibrcommon::MutexLock l(_call_mutex);

                std::list<vaddress> addresses;

                struct rtnl_addr *filter = rtnl_addr_alloc();
                const std::string i = interface.toString();
                rtnl_addr_set_ifindex(filter, rtnl_link_name2i(_link_cache, i.c_str()));

                if (f == vaddress::VADDRESS_UNSPEC)
                {
                        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);
                }
                else
                {
                        rtnl_addr_set_family(filter, f);
                        nl_cache_foreach_filter(_addr_cache, (struct nl_object *) filter,
                                                                        add_addr_to_list, &addresses);
                }

                rtnl_addr_put(filter);

                return addresses;
        }

        const std::string NetLinkManager::getInterface(const int ifindex) const
        {
                char buf[256];
                rtnl_link_i2name(_link_cache, ifindex, (char*)&buf, sizeof buf);
                return std::string((char*)&buf);
        }

        std::map<int, std::string> NetLinkManager::read_nlmsg(int fd)
        {
                char buf[1024];
                int left;
                struct sockaddr_nl from;
                socklen_t fromlen;
                struct nlmsghdr *h;

                fromlen = sizeof(from);

                // receive the netlink message
                left = recvfrom(fd, buf, sizeof(buf), MSG_DONTWAIT, (struct sockaddr *) &from, &fromlen);

                if (left < 0 && errno != EINTR && errno != EAGAIN)
                {
                        throw parse_exception("recvfrom(netlink) failed");
                }

                // cast netlink message
                h = (struct nlmsghdr *) buf;

                std::map<int, std::string> attrlist;

                while (left >= sizeof(*h))
                {
                        int len, plen;

                        len = h->nlmsg_len;

                        plen = len - sizeof(*h);

                        if (len > left || plen < 0)
                        {
                                throw parse_exception("Malformed netlink message");
                        }

                        if (h->nlmsg_type == RTM_BASE)
                        {
                                struct ifinfomsg *ifi;
                                int attrlen, nlmsg_len, rta_len;
                                struct rtattr * attr;

                                if (len < sizeof(*ifi)) return attrlist;

                                ifi = (struct ifinfomsg *)NLMSG_DATA(h);

                                nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));

                                attrlen = h->nlmsg_len - nlmsg_len;
                                if (attrlen < 0) return attrlist;

                                attr = (struct rtattr *) (((char *) ifi) + nlmsg_len);

                                rta_len = RTA_ALIGN(sizeof(struct rtattr));
                                while (RTA_OK(attr, attrlen))
                                {
                                        size_t rta_length = RTA_PAYLOAD(attr);
                                        std::string payload((char*)RTA_DATA(attr), rta_length);

                                        attrlist[attr->rta_type] = payload;
                                        attr = RTA_NEXT(attr, attrlen);
                                }
                        }

                        len = NLMSG_ALIGN(len);
                        left -= len;
                        h = (struct nlmsghdr *) ((char *) h + len);
                }

                return attrlist;
        }

        void NetLinkManager::registerInterfaceEvent(const vinterface &iface, LinkManager::EventCallback *cb)
        {
                if (cb == NULL) return;
                ibrcommon::MutexLock l(_listener_mutex);

                std::set<LinkManager::EventCallback* > &ss = _listener[iface];
                ss.insert(cb);
        }

        void NetLinkManager::unregisterInterfaceEvent(const vinterface &iface, LinkManager::EventCallback *cb)
        {
                if (cb == NULL) return;
                ibrcommon::MutexLock l(_listener_mutex);

                std::set<LinkManager::EventCallback* > &ss = _listener[iface];

                ss.erase(cb);

                if (ss.empty())
                {
                        _listener.erase(iface);
                }
        }

        void NetLinkManager::unregisterAllEvents(LinkManager::EventCallback *cb)
        {
                if (cb == NULL) return;

                try {
                        ibrcommon::MutexLock l(_listener_mutex);

                        for (std::map<vinterface, std::set<LinkManager::EventCallback* > >::iterator iter = _listener.begin(); iter != _listener.end(); iter++)
                        {
                                std::set<LinkManager::EventCallback* > &ss = iter->second;
                                ss.erase(cb);
                        }
                } catch (const ibrcommon::MutexException&) {
                        // this happens if this method is called after destroying the object
                        // and is normal at shutdown
                }
        }
}